-/* Copyright (c) 2006-2018. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2020. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
#include <simgrid/host.h>
#include <simgrid/link.h>
+#include <simgrid/version.h>
#include <xbt/log.h>
#include <xbt/sysdep.h>
#include <set>
#endif
-#ifndef MIN
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#endif
-#ifndef MAX
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-#endif
-
-SG_BEGIN_DECL()
+SG_BEGIN_DECL
/** @brief Link opaque datatype
@ingroup SD_link_api
A task is some <em>computing amount</em> that can be executed in parallel on several hosts.
A task may depend on other tasks, which means that the task cannot start until the other tasks are done.
- Each task has a <em>\ref e_SD_task_state_t "state"</em> indicating whether the task is scheduled, running, done, ...
+ Each task has a <em>@ref e_SD_task_state_t "state"</em> indicating whether the task is scheduled, running, done, ...
*/
typedef struct s_SD_task_t* SD_task_t;
+typedef const struct s_SD_task_t* const_SD_task_t;
/** @brief Task states
@ingroup SD_task_api */
*
* A task is some <em>working amount</em> that can be executed in parallel on several hosts.
* A task may depend on other tasks, which means that the task cannot start until the other tasks are done.
- * Each task has a <em>\ref e_SD_task_state_t "state"</em> indicating whether the task is scheduled, running, done, ...
+ * Each task has a <em>@ref e_SD_task_state_t "state"</em> indicating whether the task is scheduled, running, done, ...
*
* @see SD_task_t, @see SD_task_dependency_api
* @{
*/
XBT_PUBLIC SD_task_t SD_task_create(const char* name, void* data, double amount);
-XBT_PUBLIC void* SD_task_get_data(SD_task_t task);
+XBT_PUBLIC void* SD_task_get_data(const_SD_task_t task);
XBT_PUBLIC void SD_task_set_data(SD_task_t task, void* data);
-XBT_PUBLIC e_SD_task_state_t SD_task_get_state(SD_task_t task);
-XBT_PUBLIC const char* SD_task_get_name(SD_task_t task);
+XBT_PUBLIC e_SD_task_state_t SD_task_get_state(const_SD_task_t task);
+XBT_PUBLIC const char* SD_task_get_name(const_SD_task_t task);
XBT_PUBLIC void SD_task_set_name(SD_task_t task, const char* name);
XBT_PUBLIC void SD_task_set_rate(SD_task_t task, double rate);
XBT_PUBLIC void SD_task_watch(SD_task_t task, e_SD_task_state_t state);
XBT_PUBLIC void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state);
-XBT_PUBLIC double SD_task_get_amount(SD_task_t task);
+XBT_PUBLIC double SD_task_get_amount(const_SD_task_t task);
XBT_PUBLIC void SD_task_set_amount(SD_task_t task, double amount);
-XBT_PUBLIC double SD_task_get_alpha(SD_task_t task);
-XBT_PUBLIC double SD_task_get_remaining_amount(SD_task_t task);
-XBT_PUBLIC double SD_task_get_execution_time(SD_task_t task, int host_count, const sg_host_t* host_list,
+XBT_PUBLIC double SD_task_get_alpha(const_SD_task_t task);
+XBT_PUBLIC double SD_task_get_remaining_amount(const_SD_task_t task);
+XBT_PUBLIC double SD_task_get_execution_time(const_SD_task_t task, int host_count, const sg_host_t* host_list,
const double* flops_amount, const double* bytes_amount);
-XBT_PUBLIC e_SD_task_kind_t SD_task_get_kind(SD_task_t task);
+XBT_PUBLIC e_SD_task_kind_t SD_task_get_kind(const_SD_task_t task);
XBT_PUBLIC void SD_task_schedule(SD_task_t task, int host_count, const sg_host_t* host_list, const double* flops_amount,
const double* bytes_amount, double rate);
XBT_PUBLIC void SD_task_unschedule(SD_task_t task);
-XBT_PUBLIC double SD_task_get_start_time(SD_task_t task);
-XBT_PUBLIC double SD_task_get_finish_time(SD_task_t task);
-XBT_PUBLIC xbt_dynar_t SD_task_get_parents(SD_task_t task);
-XBT_PUBLIC xbt_dynar_t SD_task_get_children(SD_task_t task);
-XBT_PUBLIC int SD_task_get_workstation_count(SD_task_t task);
-XBT_PUBLIC sg_host_t* SD_task_get_workstation_list(SD_task_t task);
+XBT_PUBLIC double SD_task_get_start_time(const_SD_task_t task);
+XBT_PUBLIC double SD_task_get_finish_time(const_SD_task_t task);
+XBT_PUBLIC xbt_dynar_t SD_task_get_parents(const_SD_task_t task);
+XBT_PUBLIC xbt_dynar_t SD_task_get_children(const_SD_task_t task);
+XBT_PUBLIC int SD_task_get_workstation_count(const_SD_task_t task);
+XBT_PUBLIC sg_host_t* SD_task_get_workstation_list(const_SD_task_t task);
XBT_PUBLIC void SD_task_destroy(SD_task_t task);
-XBT_PUBLIC void SD_task_dump(SD_task_t task);
-XBT_PUBLIC void SD_task_dotty(SD_task_t task, void* out_FILE);
+XBT_PUBLIC void SD_task_dump(const_SD_task_t task);
+XBT_PUBLIC void SD_task_dotty(const_SD_task_t task, void* out_FILE);
XBT_PUBLIC SD_task_t SD_task_create_comp_seq(const char* name, void* data, double amount);
XBT_PUBLIC SD_task_t SD_task_create_comp_par_amdahl(const char* name, void* data, double amount, double alpha);
*
* For example, create a pure computation task (i.e., with no communication) like this:
*
- * SD_task_schedule(task, my_host_count, my_host_list, my_flops_amount, SD_SCHED_NO_COST, my_rate);
+ * SD_task_schedule(task, my_host_count, my_host_list, my_flops_amount, SD_SCHED_NO_COST, my_rate)
*/
#define SD_SCHED_NO_COST NULL
*/
XBT_PUBLIC void SD_task_dependency_add(SD_task_t src, SD_task_t dst);
XBT_PUBLIC void SD_task_dependency_remove(SD_task_t src, SD_task_t dst);
-XBT_PUBLIC int SD_task_dependency_exists(SD_task_t src, SD_task_t dst);
+XBT_PUBLIC int SD_task_dependency_exists(const_SD_task_t src, SD_task_t dst);
/** @} */
/************************** Global *******************************************/
#define SD_init(argc, argv) \
do { \
sg_version_check(SIMGRID_VERSION_MAJOR, SIMGRID_VERSION_MINOR, SIMGRID_VERSION_PATCH); \
- SD_init_nocheck(argc, argv); \
+ SD_init_nocheck((argc), (argv)); \
} while (0)
XBT_PUBLIC void SD_init_nocheck(int* argc, char** argv);
//SD_route_get_size
//SD_route_get_list
//TRACE_sd_set_task_category
-SG_END_DECL()
+SG_END_DECL
#ifdef __cplusplus
namespace simgrid {