drake
1.0.0
|
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