2 #include "simdag/simdag.h"
4 #include "xbt/sysdep.h"
7 /* Creates a workstation and registers it in SD.
9 SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) {
11 xbt_assert0(surf_workstation != NULL, "surf_workstation is NULL !");
13 SD_workstation_t workstation = xbt_new0(s_SD_workstation_t, 1);
14 workstation->surf_workstation = surf_workstation;
15 workstation->data = data; /* user data */
16 SD_workstation_set_access_mode(workstation, SD_WORKSTATION_SHARED_ACCESS); /* default mode is shared */
17 workstation->task_fifo = NULL;
19 const char *name = SD_workstation_get_name(workstation);
20 xbt_dict_set(sd_global->workstations, name, workstation, __SD_workstation_destroy); /* add the workstation to the dictionary */
21 sd_global->workstation_count++;
27 * \brief Returns a workstation given its name
29 * If there is no such workstation, the function returns \c NULL.
31 * \param name workstation name
32 * \return the workstation, or \c NULL if there is no such workstation
34 SD_workstation_t SD_workstation_get_by_name(const char *name) {
37 xbt_assert0(name != NULL, "Invalid parameter");
39 return xbt_dict_get_or_null(sd_global->workstations, name);
43 * \brief Returns the workstation list
45 * Use SD_workstation_get_number() to know the array size.
47 * \return an array of \ref SD_workstation_t containing all workstations
48 * \see SD_workstation_get_number()
50 const SD_workstation_t* SD_workstation_get_list(void) {
52 xbt_assert0(SD_workstation_get_number() > 0, "There is no workstation!");
54 xbt_dict_cursor_t cursor;
59 if (sd_global->workstation_list == NULL) { /* this is the first time the function is called */
60 sd_global->workstation_list = xbt_new0(SD_workstation_t, sd_global->workstation_count);
63 xbt_dict_foreach(sd_global->workstations, cursor, key, data) {
64 sd_global->workstation_list[i++] = (SD_workstation_t) data;
67 return sd_global->workstation_list;
71 * \brief Returns the number of workstations
73 * \return the number of existing workstations
74 * \see SD_workstation_get_list()
76 int SD_workstation_get_number(void) {
78 return sd_global->workstation_count;
82 * \brief Returns the user data of a workstation
84 * \param workstation a workstation
85 * \return the user data associated with this workstation (can be \c NULL)
86 * \see SD_workstation_set_data()
88 void* SD_workstation_get_data(SD_workstation_t workstation) {
90 xbt_assert0(workstation != NULL, "Invalid parameter");
91 return workstation->data;
95 * \brief Sets the user data of a workstation
97 * The new data can be \c NULL. The old data should have been freed first
98 * if it was not \c NULL.
100 * \param workstation a workstation
101 * \param data the new data you want to associate with this workstation
102 * \see SD_workstation_get_data()
104 void SD_workstation_set_data(SD_workstation_t workstation, void *data) {
105 SD_CHECK_INIT_DONE();
106 xbt_assert0(workstation != NULL, "Invalid parameter");
107 workstation->data = data;
111 * \brief Returns the name of a workstation
113 * \param workstation a workstation
114 * \return the name of this workstation (cannot be \c NULL)
116 const char* SD_workstation_get_name(SD_workstation_t workstation) {
117 SD_CHECK_INIT_DONE();
118 xbt_assert0(workstation != NULL, "Invalid parameter");
119 return surf_workstation_resource->common_public->get_resource_name(workstation->surf_workstation);
123 * \brief Returns the route between two workstations
125 * Use SD_route_get_size() to know the array size. Don't forget to free the array after use.
127 * \param src a workstation
128 * \param dst another workstation
129 * \return a new array of \ref SD_link_t representating the route between these two workstations
130 * \see SD_route_get_size(), SD_link_t
132 SD_link_t* SD_route_get_list(SD_workstation_t src, SD_workstation_t dst) {
133 SD_CHECK_INIT_DONE();
135 void *surf_src = src->surf_workstation;
136 void *surf_dst = dst->surf_workstation;
138 const void **surf_route = surf_workstation_resource->extension_public->get_route(surf_src, surf_dst);
139 int route_size = surf_workstation_resource->extension_public->get_route_size(surf_src, surf_dst);
141 SD_link_t* route = xbt_new0(SD_link_t, route_size);
142 const char *link_name;
144 for (i = 0; i < route_size; i++) {
145 link_name = surf_workstation_resource->extension_public->get_link_name(surf_route[i]);
146 route[i] = xbt_dict_get(sd_global->links, link_name);
153 * \brief Returns the number of links on the route between two workstations
155 * \param src a workstation
156 * \param dst another workstation
157 * \return the number of links on the route between these two workstations
158 * \see SD_route_get_list()
160 int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst) {
161 SD_CHECK_INIT_DONE();
162 return surf_workstation_resource->extension_public->
163 get_route_size(src->surf_workstation, dst->surf_workstation);
167 * \brief Returns the total power of a workstation
169 * \param workstation a workstation
170 * \return the total power of this workstation
171 * \see SD_workstation_get_available_power()
173 double SD_workstation_get_power(SD_workstation_t workstation) {
174 SD_CHECK_INIT_DONE();
175 xbt_assert0(workstation != NULL, "Invalid parameter");
176 return surf_workstation_resource->extension_public->get_speed(workstation->surf_workstation, 1.0);
180 * \brief Returns the proportion of available power in a workstation
182 * \param workstation a workstation
183 * \return the proportion of power currently available in this workstation (normally a number between 0 and 1)
184 * \see SD_workstation_get_power()
186 double SD_workstation_get_available_power(SD_workstation_t workstation) {
187 SD_CHECK_INIT_DONE();
188 xbt_assert0(workstation != NULL, "Invalid parameter");
189 return surf_workstation_resource->extension_public->get_available_speed(workstation->surf_workstation);
193 * \brief Returns an approximative estimated time for the given computation amount on a workstation
195 * \param workstation a workstation
196 * \param computation_amount the computation amount you want to evaluate (in flops)
197 * \return an approximative astimated computation time for the given computation amount on this workstation (in seconds)
199 double SD_workstation_get_computation_time(SD_workstation_t workstation, double computation_amount) {
200 SD_CHECK_INIT_DONE();
201 xbt_assert0(workstation != NULL, "Invalid parameter");
202 xbt_assert0(computation_amount >= 0, "computation_amount must be greater than or equal to zero");
203 return computation_amount / SD_workstation_get_power(workstation);
207 * \brief Returns the latency of the route between two workstations, i.e. the sum of all link latencies
208 * between the workstations.
210 * \param src the first workstation
211 * \param dst the second workstation
212 * \return the latency of the route between the two workstations (in seconds)
213 * \see SD_route_get_current_bandwidth()
215 double SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst) {
216 SD_CHECK_INIT_DONE();
217 xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
218 SD_link_t *links = SD_route_get_list(src, dst);
219 int nb_links = SD_route_get_size(src, dst);
220 double latency = 0.0;
223 for (i = 0; i < nb_links; i++) {
224 latency += SD_link_get_current_latency(links[i]);
232 * \brief Returns the bandwidth of the route between two workstations, i.e. the minimum link bandwidth of all
233 * between the workstations.
235 * \param src the first workstation
236 * \param dst the second workstation
237 * \return the bandwidth of the route between the two workstations (in bytes/second)
238 * \see SD_route_get_current_latency()
240 double SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst) {
241 SD_CHECK_INIT_DONE();
242 xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
243 SD_link_t *links = SD_route_get_list(src, dst);
244 int nb_links = SD_route_get_size(src, dst);
245 double bandwidth, min_bandwidth = -1.0;
248 for (i = 0; i < nb_links; i++) {
249 bandwidth = SD_link_get_current_bandwidth(links[i]);
250 if (bandwidth < min_bandwidth || min_bandwidth == -1.0)
251 min_bandwidth = bandwidth;
255 return min_bandwidth;
259 * \brief Returns an approximative estimated time for the given
260 * communication amount between two workstations
262 * \param src the first workstation
263 * \param dst the second workstation
264 * \param communication_amount the communication amount you want to evaluate (in bytes)
265 * \return an approximative astimated computation time for the given communication amount
266 * between the workstations (in seconds)
268 double SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t dst,
269 double communication_amount) {
270 /* total time = latency + transmission time of the slowest link
271 transmission time of a link = communication amount / link bandwidth */
272 SD_CHECK_INIT_DONE();
273 xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
274 xbt_assert0(communication_amount >= 0, "communication_amount must be greater than or equal to zero");
278 double bandwidth, min_bandwidth;
282 if (communication_amount == 0.0)
285 links = SD_route_get_list(src, dst);
286 nb_links = SD_route_get_size(src, dst);
287 min_bandwidth = -1.0;
290 for (i = 0; i < nb_links; i++) {
291 latency += SD_link_get_current_latency(links[i]);
292 bandwidth = SD_link_get_current_bandwidth(links[i]);
293 if (bandwidth < min_bandwidth || min_bandwidth == -1.0)
294 min_bandwidth = bandwidth;
298 return latency + (communication_amount / min_bandwidth);
302 * \brief Returns the access mode of this workstation.
304 * \param workstation a workstation
305 * \return the access mode for the tasks running on this workstation:
306 * SD_WORKSTATION_SHARED_ACCESS or SD_WORKSTATION_SEQUENTIAL_ACCESS
308 * \see SD_workstation_set_access_mode(), e_SD_workstation_access_mode_t
310 e_SD_workstation_access_mode_t SD_workstation_get_access_mode(SD_workstation_t workstation) {
311 SD_CHECK_INIT_DONE();
312 xbt_assert0(workstation != NULL, "Invalid parameter");
313 return workstation->access_mode;
317 * \brief Sets the access mode for the tasks that will be executed on a workstation
319 * By default, a workstation resource is shared, i.e. several tasks
320 * can be executed at the same time on a workstation. The CPU power of
321 * the workstation is shared between the running tasks on the workstation.
322 * In sequential mode, only one task can use the workstation, and the other
323 * tasks wait in a FIFO.
325 * \param workstation a workstation
326 * \param access_mode the access mode you want to set to this workstation:
327 * SD_WORKSTATION_SHARED_ACCESS or SD_WORKSTATION_SEQUENTIAL_ACCESS
329 * \see SD_workstation_get_access_mode(), e_SD_workstation_access_mode_t
331 void SD_workstation_set_access_mode(SD_workstation_t workstation, e_SD_workstation_access_mode_t access_mode) {
332 SD_CHECK_INIT_DONE();
333 xbt_assert0(workstation != NULL, "Invalid parameter");
335 if (access_mode == workstation->access_mode) {
336 return; // nothing is changed
339 workstation->access_mode = access_mode;
341 if (access_mode == SD_WORKSTATION_SHARED_ACCESS) {
342 xbt_fifo_free(workstation->task_fifo);
343 workstation->task_fifo = NULL;
346 workstation->task_fifo = xbt_fifo_new();
350 /* Returns whether a task can start now on a workstation.
352 int __SD_workstation_can_start(SD_workstation_t workstation, SD_task_t task) {
353 SD_CHECK_INIT_DONE();
354 xbt_assert0(workstation != NULL && task != NULL, "Invalid parameter");
356 return !__SD_workstation_is_busy(workstation) &&
357 (xbt_fifo_size(workstation->task_fifo) == 0) || xbt_fifo_get_first_item(workstation->task_fifo) == task);
361 /* Returns whether a workstation is busy. A workstation is busy is it is
362 * in sequential mode and a task is running on it or the fifo is not empty.
364 int __SD_workstation_is_busy(SD_workstation_t workstation) {
365 SD_CHECK_INIT_DONE();
366 xbt_assert0(workstation != NULL, "Invalid parameter");
368 return workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS &&
369 (workstation->current_task != NULL || xbt_fifo_size(workstation->task_fifo) > 0);
372 /* Destroys a workstation.
374 void __SD_workstation_destroy(void *workstation) {
375 SD_CHECK_INIT_DONE();
376 xbt_assert0(workstation != NULL, "Invalid parameter");
377 /* workstation->surf_workstation is freed by surf_exit and workstation->data is freed by the user */
379 SD_workstation_t w = (SD_workstation_t) workstation;
381 if (w->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
382 xbt_fifo_free(w->task_fifo);