drake  1.0.0
src/processor.c
Go to the documentation of this file.
00001 /*
00002  Copyright 2015 Nicolas Melot
00003 
00004  This file is part of Drake.
00005 
00006  Drake is free software: you can redistribute it and/or modify
00007  it under the terms of the GNU General Public License as published by
00008  the Free Software Foundation, either version 3 of the License, or
00009  (at your option) any later version.
00010 
00011  Drake is distributed in the hope that it will be useful,
00012  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00014  GNU General Public License for more details.
00015 
00016  You should have received a copy of the GNU General Public License
00017  along with Drake. If not, see <http://www.gnu.org/licenses/>.
00018 
00019 */
00020 
00021 
00022 #include <stdlib.h>
00023 #include <string.h>
00024 
00025 #include <drake/processor.h>
00026 #include <drake/platform.h>
00027 
00028 processor_t*
00029 pelib_alloc_collection(processor_t)(size_t size)
00030 {
00031   int i, res;
00032   processor_t *proc;
00033 
00034   proc = malloc(sizeof(processor_t));
00035   res = 1;
00036 
00037   if (proc != NULL)
00038     {
00039       proc->handled_nodes = 0;
00040       proc->node_capacity = size;
00041       proc->task = malloc(sizeof(task_t*) * size);
00042       if(proc->task != NULL)
00043       {
00044 
00045       for (i = 0; i < proc->node_capacity; i++)
00046         {
00047           proc->task[i] = malloc(sizeof(task_t));
00048           res = res && (proc->task[i] != NULL);
00049         }
00050 
00051       if (res == 1)
00052         {
00053           return proc;
00054         }
00055       }
00056 
00057       // If something went wrong, free all tasks and task array
00058       for (i = 0; i < proc->node_capacity; i++)
00059       {
00060         free(proc->task[i]);
00061       }
00062       free(proc->task);
00063     }
00064 
00065   free(proc);
00066   return NULL;
00067 }
00068 
00069 int
00070 pelib_free(processor_t)(processor_t * proc)
00071 {
00072   size_t i;
00073 
00074   for (i = 0; i < proc->node_capacity; i++)
00075     {
00076       free(proc->task[i]);
00077     }
00078   free(proc->task);
00079   free(proc);
00080 
00081   return 1;
00082 }
00083 
00084 int
00085 pelib_copy(processor_t)(processor_t source, processor_t * copy)
00086 {
00087   size_t i;
00088 
00089   //copy = pelib_alloc_collection(processor_t)(source.node_capacity);
00090   copy->id = source.id;
00091   copy->source = source.source;
00092   copy->sink = source.sink;
00093 
00094   for (i = 0; i < source.handled_nodes; i++)
00095     {
00096       drake_processor_insert_task(copy, source.task[i]);
00097     }
00098 
00099   
00100 
00101   return 1;
00102 }
00103 
00104 char*
00105 pelib_string(processor_t)(processor_t proc)
00106 {
00107   size_t i;
00108   char *str_p, *str_node;
00109   char *str;
00110 
00111   str = malloc(sizeof(char) * (DRAKE_MAPPING_PROC_ID_CHAR_LENGTH
00112       + (sizeof(DRAKE_MAPPING_SEPARATOR) + DRAKE_MAPPING_NODE_CHAR_LENGTH)
00113           * proc.handled_nodes + 1));
00114 
00115   sprintf(str, "%u", proc.id);
00116   str_p = &(str[strlen(str)]);
00117 
00118   for (i = 0; i < proc.handled_nodes; i++)
00119     {
00120       str_node = pelib_string(task_tp)(proc.task[i]);
00121       sprintf(str_p, "%c%s", DRAKE_MAPPING_SEPARATOR, str_node);
00122       free(str_node);
00123       str_p = &(str[strlen(str)]);
00124     }
00125 
00126   return str;
00127 }
00128 
00129 // Processor human interface
00130 FILE*
00131 pelib_printf(processor_t)(FILE* stream, processor_t proc)
00132 {
00133   char *str = pelib_string(processor_t)(proc);
00134 
00135   printf("%s", str);
00136   free(str);
00137 
00138   return stream;
00139 }
00140 
00141 int
00142 drake_processor_insert_task(processor_t * proc, task_t * task)
00143 {
00144   if (!(drake_processor_find_task(proc, task->id) < proc->handled_nodes))
00145     {
00146 /*
00147       if(proc->task[proc->handled_nodes]->core != NULL)
00148       {
00149         processor_t **list = task->core;
00150         task = malloc(sizeof(processor_t*) * task->width + 1);
00151         memcpy(task->core, list, sizeof(processor_t*) * task->width);
00152         task->core[sizeof(processor_t*) * task->width] = proc;
00153         task->width++;
00154       }
00155       else
00156       {
00157         task->core = malloc(sizeof(processor_t*));
00158         task->core[0] = proc;
00159         task->width = 1;
00160       }
00161 */
00162       *(proc->task[proc->handled_nodes]) = *task;
00163       proc->handled_nodes++;
00164 
00165       return 1;
00166     }
00167   else
00168     {
00169       return 0;
00170     }
00171 }
00172 
00173 int
00174 drake_processor_remove_task(processor_t * proc, task_id task)
00175 {
00176   size_t index;
00177   task_t * pivot;
00178 
00179   index = drake_processor_find_task(proc, task);
00180   if (index < proc->handled_nodes)
00181     {
00182       pivot = proc->task[index];
00183       proc->task[index]->core = NULL;
00184       proc->task[index] = proc->task[proc->handled_nodes - 1];
00185       proc->task[proc->handled_nodes - 1] = pivot;
00186 
00187       proc->handled_nodes--;
00188 
00189       return 1;
00190     }
00191   else
00192     {
00193       return 0;
00194     }
00195 }
00196 
00197 // Processors properties
00198 size_t
00199 drake_processor_find_task(processor_t * proc, task_id task)
00200 {
00201   size_t i;
00202   task_t * p_node;
00203 
00204 size_t r = proc->handled_nodes;
00205   for (i = 0; i < r; i++)
00206     {
00207       p_node = proc->task[i];
00208       if (p_node->id == task)
00209         {
00210           return i;
00211         }
00212     }
00213 
00214   return proc->handled_nodes;
00215 }
00216