1 /* Copyright (c) 2006-2010, 2012-2015. The SimGrid Team.
2 * All rights reserved. */
4 /* This program is free software; you can redistribute it and/or modify it
5 * under the terms of the license (GNU LGPL) which comes with this package. */
7 #ifndef SIMDAG_SIMDAG_H
8 #define SIMDAG_SIMDAG_H
11 #include "xbt/dynar.h"
14 #include "simgrid/link.h"
17 /** @brief Workstation datatype
18 @ingroup SD_datatypes_management
20 A workstation is a place where a task can be executed.
21 A workstation is represented as a <em>physical
22 resource with computing capabilities</em> and has a <em>name</em>.
24 @see SD_workstation_management */
25 typedef sg_host_t SD_workstation_t;
27 /** @brief Workstation access mode
28 @ingroup SD_datatypes_management
30 By default, a workstation resource is shared, i.e. several tasks
31 can be executed at the same time on a workstation. The CPU power of
32 the workstation is shared between the running tasks on the workstation.
33 In sequential mode, only one task can use the workstation, and the other
36 @see SD_workstation_get_access_mode(), SD_workstation_set_access_mode() */
38 SD_WORKSTATION_SHARED_ACCESS, /**< @brief Several tasks can be executed at the same time */
39 SD_WORKSTATION_SEQUENTIAL_ACCESS /**< @brief Only one task can be executed, the others wait in a FIFO. */
40 } e_SD_workstation_access_mode_t;
42 /** @brief Link datatype
43 @ingroup SD_datatypes_management
45 A link is a network node represented as a <em>name</em>, a <em>current
46 bandwidth</em> and a <em>current latency</em>. A route is a list of
47 links between two workstations.
49 @see SD_link_management */
50 typedef Link *SD_link_t;
52 /** @brief Task datatype
53 @ingroup SD_datatypes_management
55 A task is some <em>computing amount</em> that can be executed
56 in parallel on several workstations. A task may depend on other
57 tasks, this means that the task cannot start until the other tasks are done.
58 Each task has a <em>\ref e_SD_task_state_t "state"</em> indicating whether
59 the task is scheduled, running, done, etc.
61 @see SD_task_management */
62 typedef struct SD_task *SD_task_t;
64 /** @brief Task states
65 @ingroup SD_datatypes_management
67 @see SD_task_management */
69 SD_NOT_SCHEDULED = 0, /**< @brief Initial state (not valid for SD_watch and SD_unwatch). */
70 SD_SCHEDULABLE = 0x0001, /**< @brief A task becomes SD_SCHEDULABLE as soon as its dependencies are satisfied */
71 SD_SCHEDULED = 0x0002, /**< @brief A task becomes SD_SCHEDULED when you call function
72 SD_task_schedule. SD_simulate will execute it when it becomes SD_RUNNABLE. */
73 SD_RUNNABLE = 0x0004, /**< @brief A scheduled task becomes runnable is SD_simulate as soon as its dependencies are satisfied. */
74 SD_IN_FIFO = 0x0008, /**< @brief A runnable task can have to wait in a workstation fifo if the workstation is sequential */
75 SD_RUNNING = 0x0010, /**< @brief An SD_RUNNABLE or SD_IN_FIFO becomes SD_RUNNING when it is launched. */
76 SD_DONE = 0x0020, /**< @brief The task is successfully finished. */
77 SD_FAILED = 0x0040 /**< @brief A problem occurred during the execution of the task. */
81 @ingroup SD_datatypes_management
83 @see SD_task_management */
85 SD_TASK_NOT_TYPED = 0, /**< @brief no specified type */
86 SD_TASK_COMM_E2E = 1, /**< @brief end to end communication */
87 SD_TASK_COMP_SEQ = 2, /**< @brief sequential computation */
88 SD_TASK_COMP_PAR_AMDAHL = 3, /**< @brief parallel computation (Amdahl's law) */
89 SD_TASK_COMM_PAR_MXN_1D_BLOCK = 4 /**< @brief MxN data redistribution (1D Block distribution) */
93 /** @brief Storage datatype
94 @ingroup SD_datatypes_management
98 @see SD_storage_management */
99 typedef xbt_dictelm_t SD_storage_t;
101 /************************** Workstation handling ****************************/
103 /** @defgroup SD_workstation_management Workstations
104 * @brief Functions for managing the workstations
106 * This section describes the functions for managing the workstations.
108 * A workstation is a place where a task can be executed.
109 * A workstation is represented as a <em>physical
110 * resource with computing capabilities</em> and has a <em>name</em>.
112 * The workstations are created when you call the function SD_create_environment.
114 * @see SD_workstation_t
117 XBT_PUBLIC(SD_workstation_t) SD_workstation_get_by_name(const char *name);
118 XBT_PUBLIC(const SD_workstation_t *) SD_workstation_get_list(void);
119 XBT_PUBLIC(int) SD_workstation_get_count(void);
120 XBT_PUBLIC(void) SD_workstation_set_data(SD_workstation_t workstation,
122 XBT_PUBLIC(void *) SD_workstation_get_data(SD_workstation_t workstation);
123 XBT_PUBLIC(const char *) SD_workstation_get_name(SD_workstation_t
125 /*property handling functions*/
126 XBT_PUBLIC(xbt_dict_t) SD_workstation_get_properties(SD_workstation_t
128 XBT_PUBLIC(const char *) SD_workstation_get_property_value(SD_workstation_t
132 XBT_PUBLIC(void) SD_workstation_dump(SD_workstation_t ws);
133 XBT_PUBLIC(const SD_link_t *) SD_route_get_list(SD_workstation_t src,
134 SD_workstation_t dst);
135 XBT_PUBLIC(int) SD_route_get_size(SD_workstation_t src,
136 SD_workstation_t dst);
137 XBT_PUBLIC(double) SD_workstation_get_speed(SD_workstation_t workstation);
138 XBT_PUBLIC(double) SD_workstation_get_available_speed(SD_workstation_t
140 XBT_PUBLIC(int) SD_workstation_get_cores(SD_workstation_t workstation);
141 XBT_PUBLIC(e_SD_workstation_access_mode_t)
142 SD_workstation_get_access_mode(SD_workstation_t workstation);
143 XBT_PUBLIC(void) SD_workstation_set_access_mode(SD_workstation_t
145 e_SD_workstation_access_mode_t
148 XBT_PUBLIC(double) SD_workstation_get_computation_time(SD_workstation_t workstation,
149 double flops_amount);
150 XBT_PUBLIC(double) SD_route_get_latency(SD_workstation_t src,
151 SD_workstation_t dst);
152 XBT_PUBLIC(double) SD_route_get_bandwidth(SD_workstation_t src,
153 SD_workstation_t dst);
154 XBT_PUBLIC(double) SD_route_get_communication_time(SD_workstation_t src,
155 SD_workstation_t dst,
156 double bytes_amount);
158 XBT_PUBLIC(SD_task_t) SD_workstation_get_current_task(SD_workstation_t workstation);
159 XBT_PUBLIC(xbt_dict_t)
160 SD_workstation_get_mounted_storage_list(SD_workstation_t workstation);
161 XBT_PUBLIC(xbt_dynar_t)
162 SD_workstation_get_attached_storage_list(SD_workstation_t workstation);
163 XBT_PUBLIC(const char*) SD_storage_get_host(SD_storage_t storage);
166 /************************** Task handling ************************************/
168 /** @defgroup SD_task_management Tasks
169 * @brief Functions for managing the tasks
171 * This section describes the functions for managing the tasks.
173 * A task is some <em>working amount</em> that can be executed
174 * in parallel on several workstations. A task may depend on other
175 * tasks, this means that the task cannot start until the other tasks are done.
176 * Each task has a <em>\ref e_SD_task_state_t "state"</em> indicating whether
177 * the task is scheduled, running, done, etc.
179 * @see SD_task_t, SD_task_dependency_management
182 XBT_PUBLIC(SD_task_t) SD_task_create(const char *name, void *data,
184 XBT_PUBLIC(void *) SD_task_get_data(SD_task_t task);
185 XBT_PUBLIC(void) SD_task_set_data(SD_task_t task, void *data);
186 XBT_PUBLIC(e_SD_task_state_t) SD_task_get_state(SD_task_t task);
187 XBT_PUBLIC(const char *) SD_task_get_name(SD_task_t task);
188 XBT_PUBLIC(void) SD_task_set_name(SD_task_t task, const char *name);
189 XBT_PUBLIC(void) SD_task_set_rate(SD_task_t task, double rate);
191 XBT_PUBLIC(void) SD_task_watch(SD_task_t task, e_SD_task_state_t state);
192 XBT_PUBLIC(void) SD_task_unwatch(SD_task_t task, e_SD_task_state_t state);
193 XBT_PUBLIC(double) SD_task_get_amount(SD_task_t task);
194 XBT_PUBLIC(void) SD_task_set_amount(SD_task_t task, double amount);
195 XBT_PUBLIC(double) SD_task_get_alpha(SD_task_t task);
196 XBT_PUBLIC(double) SD_task_get_remaining_amount(SD_task_t task);
197 XBT_PUBLIC(double) SD_task_get_execution_time(SD_task_t task,
199 const SD_workstation_t *
201 const double *flops_amount,
202 const double *bytes_amount);
203 XBT_PUBLIC(e_SD_task_kind_t) SD_task_get_kind(SD_task_t task);
204 XBT_PUBLIC(void) SD_task_schedule(SD_task_t task, int workstation_nb,
205 const SD_workstation_t *
207 const double *flops_amount,
208 const double *bytes_amount,
210 XBT_PUBLIC(void) SD_task_unschedule(SD_task_t task);
211 XBT_PUBLIC(double) SD_task_get_start_time(SD_task_t task);
212 XBT_PUBLIC(double) SD_task_get_finish_time(SD_task_t task);
213 XBT_PUBLIC(xbt_dynar_t) SD_task_get_parents(SD_task_t task);
214 XBT_PUBLIC(xbt_dynar_t) SD_task_get_children(SD_task_t task);
215 XBT_PUBLIC(int) SD_task_get_workstation_count(SD_task_t task);
216 XBT_PUBLIC(SD_workstation_t *) SD_task_get_workstation_list(SD_task_t
218 XBT_PUBLIC(void) SD_task_destroy(SD_task_t task);
219 XBT_PUBLIC(void) SD_task_dump(SD_task_t task);
220 XBT_PUBLIC(void) SD_task_dotty(SD_task_t task, void *out_FILE);
222 XBT_PUBLIC(SD_task_t) SD_task_create_comp_seq(const char *name, void *data,
224 XBT_PUBLIC(SD_task_t) SD_task_create_comp_par_amdahl(const char *name,
228 XBT_PUBLIC(SD_task_t) SD_task_create_comm_e2e(const char *name, void *data,
230 XBT_PUBLIC(SD_task_t) SD_task_create_comm_par_mxn_1d_block(const char *name,
234 XBT_PUBLIC(void) SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count);
235 XBT_PUBLIC(void) SD_task_schedulev(SD_task_t task, int count,
236 const SD_workstation_t * list);
237 XBT_PUBLIC(void) SD_task_schedulel(SD_task_t task, int count, ...);
240 /** @brief A constant to use in SD_task_schedule to mean that there is no cost.
242 * For example, create a pure computation task (no comm) like this:
244 * SD_task_schedule(task, my_workstation_nb,
245 * my_workstation_list,
247 * SD_TASK_SCHED_NO_COST,
250 #define SD_SCHED_NO_COST NULL
255 /** @defgroup SD_task_dependency_management Tasks dependencies
256 * @brief Functions for managing the task dependencies
258 * This section describes the functions for managing the dependencies between the tasks.
260 * @see SD_task_management
263 XBT_PUBLIC(void) SD_task_dependency_add(const char *name, void *data,
264 SD_task_t src, SD_task_t dst);
265 XBT_PUBLIC(void) SD_task_dependency_remove(SD_task_t src, SD_task_t dst);
266 XBT_PUBLIC(const char *) SD_task_dependency_get_name(SD_task_t src,
268 XBT_PUBLIC(void *) SD_task_dependency_get_data(SD_task_t src,
270 XBT_PUBLIC(int) SD_task_dependency_exists(SD_task_t src, SD_task_t dst);
273 /************************** Global *******************************************/
275 /** @defgroup SD_simulation Simulation
276 * @brief Functions for creating the environment and launching the simulation
278 * This section describes the functions for initializing SimDag, launching
279 * the simulation and exiting SimDag.
283 XBT_PUBLIC(void) SD_init(int *argc, char **argv);
284 XBT_PUBLIC(void) SD_config(const char *key, const char *value);
285 XBT_PUBLIC(void) SD_application_reinit(void);
286 XBT_PUBLIC(void) SD_create_environment(const char *platform_file);
287 XBT_PUBLIC(xbt_dynar_t) SD_simulate(double how_long);
288 XBT_PUBLIC(double) SD_get_clock(void);
289 XBT_PUBLIC(void) SD_exit(void);
290 XBT_PUBLIC(xbt_dynar_t) SD_daxload(const char *filename);
291 XBT_PUBLIC(xbt_dynar_t) SD_dotload(const char *filename);
292 XBT_PUBLIC(xbt_dynar_t) SD_PTG_dotload(const char *filename);
293 XBT_PUBLIC(xbt_dynar_t) SD_dotload_with_sched(const char *filename);
299 #include "simgrid/instr.h"