*/
#define YY_LESS_LINENO(n) \
do { \
- int yyl;\
+ unsigned int yyl;\
for ( yyl = n; yyl < dax_leng; ++yyl )\
if ( dax_text[yyl] == '\n' )\
--dax_lineno;\
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_daxparse, sd, "Parsing DAX files");
-#undef CLEANUP
-#include "dax_dtd.h"
-#include "dax_dtd.c"
+extern "C" {
+ #undef CLEANUP
+ #include "dax_dtd.h"
+ #include "dax_dtd.c"
+}
bool children_are_marked(SD_task_t task);
bool parents_are_marked(SD_task_t task);
static void dax_task_free(void *task)
{
- SD_task_t t = task;
- SD_task_destroy(t);
+ SD_task_destroy((SD_task_t)task);
}
/** @brief loads a DAX file describing a DAG
int is_input = (A_dax__uses_link == A_dax__uses_link_input);
// XBT_INFO("See <uses file=%s %s>",A_dax__uses_file,(is_input?"in":"out"));
- file = xbt_dict_get_or_null(files, A_dax__uses_file);
+ file = (SD_task_t)xbt_dict_get_or_null(files, A_dax__uses_file);
if (file == NULL) {
file = SD_task_create_comm_e2e(A_dax__uses_file, NULL, size);
xbt_dict_set(files, A_dax__uses_file, file, NULL);
static SD_task_t current_child;
void STag_dax__child(void)
{
- current_child = xbt_dict_get_or_null(jobs, A_dax__child_ref);
+ current_child = (SD_task_t)xbt_dict_get_or_null(jobs, A_dax__child_ref);
if (current_child == NULL)
dax_parse_error(bprintf
("Asked to add dependencies to the non-existent %s task",
void STag_dax__parent(void)
{
- SD_task_t parent = xbt_dict_get_or_null(jobs, A_dax__parent_ref);
+ SD_task_t parent = (SD_task_t)xbt_dict_get_or_null(jobs, A_dax__parent_ref);
if (parent == NULL)
dax_parse_error(bprintf
("Asked to add a dependency from %s to %s, but %s does not exist",
SD_task_t task;
SD_simulate_swag(how_long);
- while( (task = xbt_swag_extract(sd_global->return_set)) != NULL) {
+ while( (task = (SD_task_t)xbt_swag_extract(sd_global->return_set)) != NULL) {
xbt_dynar_push(changed_tasks, &task);
}
/* let's see which tasks are done */
xbt_dynar_foreach(all_existing_models, iter, model) {
while ((action = surf_model_extract_done_action_set(model))) {
- task = surf_action_get_data(action);
+ task = (SD_task_t)surf_action_get_data(action);
task->start_time = surf_action_get_start_time(task->surf_action);
task->finish_time = surf_get_clock();
/* let's see which tasks have just failed */
while ((action = surf_model_extract_failed_action_set(model))) {
- task = surf_action_get_data(action);
+ task = (SD_task_t)surf_action_get_data(action);
task->start_time = surf_action_get_start_time(task->surf_action);
task->finish_time = surf_get_clock();
XBT_VERB("Task '%s' failed", SD_task_get_name(task));
*/
SD_task_t SD_task_create(const char *name, void *data, double amount)
{
- SD_task_t task = xbt_mallocator_get(sd_global->task_mallocator);
+ SD_task_t task = (SD_task_t)xbt_mallocator_get(sd_global->task_mallocator);
/* general information */
task->data = data; /* user data */
{
unsigned int counter;
SD_dependency_t dependency;
- fprintf(out, " T%p [label=\"%.20s\"", task, task->name);
+ FILE *fout = (FILE*)out;
+ fprintf(fout, " T%p [label=\"%.20s\"", task, task->name);
switch (task->kind) {
case SD_TASK_COMM_E2E:
case SD_TASK_COMM_PAR_MXN_1D_BLOCK:
- fprintf(out, ", shape=box");
+ fprintf(fout, ", shape=box");
break;
case SD_TASK_COMP_SEQ:
case SD_TASK_COMP_PAR_AMDAHL:
- fprintf(out, ", shape=circle");
+ fprintf(fout, ", shape=circle");
break;
default:
xbt_die("Unknown task type!");
}
- fprintf(out, "];\n");
+ fprintf(fout, "];\n");
xbt_dynar_foreach(task->tasks_before, counter, dependency) {
- fprintf(out, " T%p -> T%p;\n", dependency->src, dependency->dst);
+ fprintf(fout, " T%p -> T%p;\n", dependency->src, dependency->dst);
}
}
task->rate = rate;
if (flops_amount) {
- task->flops_amount = xbt_realloc(task->flops_amount,
+ task->flops_amount = (double*)xbt_realloc(task->flops_amount,
sizeof(double) * workstation_count);
memcpy(task->flops_amount, flops_amount,
sizeof(double) * workstation_count);
communication_nb = workstation_count * workstation_count;
if (bytes_amount) {
- task->bytes_amount = xbt_realloc(task->bytes_amount,
+ task->bytes_amount = (double*)xbt_realloc(task->bytes_amount,
sizeof(double) * communication_nb);
memcpy(task->bytes_amount, bytes_amount,
sizeof(double) * communication_nb);
task->bytes_amount = NULL;
}
- task->workstation_list =
+ task->workstation_list = (SD_workstation_t*)
xbt_realloc(task->workstation_list,
sizeof(SD_workstation_t) * workstation_count);
memcpy(task->workstation_list, workstation_list,
sg_host_sd(workstation)->current_task = NULL;
XBT_DEBUG("Getting candidate in FIFO");
- candidate =
+ candidate = (SD_task_t)
xbt_fifo_get_item_content(xbt_fifo_get_first_item
(sg_host_sd(workstation)->task_fifo));
/* realloc if necessary */
if (candidate_nb == candidate_capacity) {
candidate_capacity *= 2;
- candidates =
+ candidates = (SD_task_t*)
xbt_realloc(candidates,
sizeof(SD_task_t) * candidate_capacity);
}
/* update the FIFO */
if (sg_host_sd(workstation)->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
- candidate = xbt_fifo_shift(sg_host_sd(workstation)->task_fifo); /* the return value is stored just for debugging */
+ candidate = (SD_task_t)xbt_fifo_shift(sg_host_sd(workstation)->task_fifo); /* the return value is stored just for debugging */
XBT_DEBUG("Head of the FIFO: '%s'",
(candidate !=
NULL) ? SD_task_get_name(candidate) : "NULL");
storage = xbt_new(s_SD_storage_priv_t, 1);
storage->data = data; /* user data */
- name = surf_resource_name(surf_storage);
- storage->host = surf_storage_get_host(surf_storage_resource_by_name(name));
+ name = surf_resource_name((surf_cpp_resource_t)surf_storage);
+ storage->host = (const char*)surf_storage_get_host( (surf_resource_t )surf_storage_resource_by_name(name));
xbt_lib_set(storage_lib,name, SD_STORAGE_LEVEL, storage);
return xbt_lib_get_elm_or_null(storage_lib, name);
}
xbt_assert(SD_workstation_get_number() > 0, "There is no workstation!");
if (sd_global->workstation_list == NULL) /* this is the first time the function is called */
- sd_global->workstation_list = xbt_dynar_to_array(sg_hosts_as_dynar());
+ sd_global->workstation_list = (SD_workstation_t*)xbt_dynar_to_array(sg_hosts_as_dynar());
return sd_global->workstation_list;
}
const char *SD_workstation_get_property_value(SD_workstation_t ws,
const char *name)
{
- return xbt_dict_get_or_null(SD_workstation_get_properties(ws), name);
+ return (const char*) xbt_dict_get_or_null(SD_workstation_get_properties(ws), name);
}
const SD_link_t *SD_route_get_list(SD_workstation_t src,
SD_workstation_t dst)
{
- void *surf_src;
- void *surf_dst;
xbt_dynar_t surf_route;
void *surf_link;
unsigned int cpt;
sd_global->recyclable_route = xbt_new(SD_link_t, SD_link_get_number());
}
- surf_src = src;
- surf_dst = dst;
-
- surf_route = surf_host_model_get_route((surf_host_model_t)surf_host_model,
- surf_src, surf_dst);
+ surf_route = surf_host_model_get_route((surf_host_model_t)surf_host_model, src, dst);
xbt_dynar_foreach(surf_route, cpt, surf_link) {
- sd_global->recyclable_route[cpt] = surf_link;
+ sd_global->recyclable_route[cpt] = (SD_link_t)surf_link;
}
return sd_global->recyclable_route;
}
{
xbt_dict_t dict = get_as_router_properties(asr);
if(!dict) return NULL;
- return xbt_dict_get_or_null(dict,name);
+ return (const char*)xbt_dict_get_or_null(dict,name);
}
src/simdag/dax.dtd
src/simdag/dax_dtd.c
src/simdag/dax_dtd.h
- src/simdag/private.h
+ src/simdag/simdag_private.h
src/simix/simcalls.in
src/simix/simcalls.py
src/simix/popping_private.h
)
set(SIMDAG_SRC
- src/simdag/instr_sd_task.c
- src/simdag/sd_daxloader.c
- src/simdag/sd_global.c
- src/simdag/sd_link.c
- src/simdag/sd_task.c
- src/simdag/sd_workstation.c
+ src/simdag/instr_sd_task.cpp
+ src/simdag/sd_daxloader.cpp
+ src/simdag/sd_global.cpp
+ src/simdag/sd_link.cpp
+ src/simdag/sd_task.cpp
+ src/simdag/sd_workstation.cpp
)
if(HAVE_GRAPHVIZ)
set(SIMDAG_SRC
- ${SIMDAG_SRC} src/simdag/sd_dotloader.c
+ ${SIMDAG_SRC} src/simdag/sd_dotloader.cpp
)
else()
set(EXTRA_DIST
- ${EXTRA_DIST} src/simdag/sd_dotloader.c
+ ${EXTRA_DIST} src/simdag/sd_dotloader.cpp
)
endif()
