From e6f7f709a42562f77d630d5c02883f031a108d1b Mon Sep 17 00:00:00 2001 From: Christian Heinrich Date: Wed, 8 Jun 2016 23:20:59 +0200 Subject: [PATCH] [SIMDAG] NULL -> nullptr substitution I used the following command: (the '**' means recursion in ZSH) sed -i -e 's/\([^_]\s*\)NULL/\1nullptr/g' src/**/*.cpp We check for the underscore to avoid replacing MPI_*_NULL --- src/simdag/sd_daxloader.cpp | 88 +++++++++++++++++----------------- src/simdag/sd_dotloader.cpp | 54 ++++++++++----------- src/simdag/sd_global.cpp | 20 ++++---- src/simdag/sd_task.cpp | 90 +++++++++++++++++------------------ src/simdag/sd_workstation.cpp | 6 +-- 5 files changed, 129 insertions(+), 129 deletions(-) diff --git a/src/simdag/sd_daxloader.cpp b/src/simdag/sd_daxloader.cpp index 1b7109c698..ff5f178ce8 100644 --- a/src/simdag/sd_daxloader.cpp +++ b/src/simdag/sd_daxloader.cpp @@ -50,7 +50,7 @@ void uniq_transfer_task_name(SD_task_t task) } static bool children_are_marked(SD_task_t task){ - SD_dependency_t depafter = NULL; + SD_dependency_t depafter = nullptr; unsigned int count; xbt_dynar_foreach(task->tasks_after,count,depafter){ @@ -61,7 +61,7 @@ static bool children_are_marked(SD_task_t task){ } static bool parents_are_marked(SD_task_t task){ - SD_dependency_t depbefore = NULL; + SD_dependency_t depbefore = nullptr; unsigned int count; xbt_dynar_foreach(task->tasks_before,count,depbefore){ if(depbefore->src->marked == 0) @@ -73,9 +73,9 @@ static bool parents_are_marked(SD_task_t task){ bool acyclic_graph_detail(xbt_dynar_t dag){ unsigned int count, count_current=0; bool all_marked = true; - SD_task_t task = NULL, parent_task = NULL, child_task = NULL; - SD_dependency_t depbefore = NULL, depafter = NULL; - xbt_dynar_t next = NULL, current = xbt_dynar_new(sizeof(SD_task_t),NULL); + SD_task_t task = nullptr, parent_task = nullptr, child_task = nullptr; + SD_dependency_t depbefore = nullptr, depafter = nullptr; + xbt_dynar_t next = nullptr, current = xbt_dynar_new(sizeof(SD_task_t),nullptr); xbt_dynar_foreach(dag,count,task){ if(task->kind == SD_TASK_COMM_E2E) continue; @@ -86,10 +86,10 @@ bool acyclic_graph_detail(xbt_dynar_t dag){ } //test if something has to be done for the next iteration while(!xbt_dynar_is_empty(current)){ - next = xbt_dynar_new(sizeof(SD_task_t),NULL); + next = xbt_dynar_new(sizeof(SD_task_t),nullptr); //test if the current iteration is done xbt_dynar_foreach(current,count_current,task){ - if (task == NULL) continue; + if (task == nullptr) continue; //push task in next task->marked = 1; xbt_dynar_foreach(task->tasks_before,count,depbefore){ @@ -97,7 +97,7 @@ bool acyclic_graph_detail(xbt_dynar_t dag){ if(parent_task->kind == SD_TASK_COMM_E2E){ unsigned int j=0; parent_task->marked = 1; - SD_task_t parent_task_2 = NULL; + SD_task_t parent_task_2 = nullptr; xbt_dynar_foreach(parent_task->tasks_before,j,depbefore){ parent_task_2 = depbefore->src; if(children_are_marked(parent_task_2)) @@ -107,12 +107,12 @@ bool acyclic_graph_detail(xbt_dynar_t dag){ if(children_are_marked(parent_task)) xbt_dynar_push(next, &parent_task); } - parent_task = NULL; + parent_task = nullptr; } } xbt_dynar_free(¤t); current = next; - next = NULL; + next = nullptr; } xbt_dynar_free(¤t); all_marked = true; @@ -128,7 +128,7 @@ bool acyclic_graph_detail(xbt_dynar_t dag){ if(!all_marked){ XBT_VERB("there is at least one cycle in your task graph"); - current = xbt_dynar_new(sizeof(SD_task_t),NULL); + current = xbt_dynar_new(sizeof(SD_task_t),nullptr); xbt_dynar_foreach(dag,count,task){ if(task->kind == SD_TASK_COMM_E2E) continue; if(xbt_dynar_is_empty(task->tasks_before)){ @@ -145,10 +145,10 @@ bool acyclic_graph_detail(xbt_dynar_t dag){ } //test if something has to be done for the next iteration while(!xbt_dynar_is_empty(current)){ - next = xbt_dynar_new(sizeof(SD_task_t),NULL); + next = xbt_dynar_new(sizeof(SD_task_t),nullptr); //test if the current iteration is done xbt_dynar_foreach(current,count_current,task){ - if (task == NULL) continue; + if (task == nullptr) continue; //push task in next task->marked = 1; xbt_dynar_foreach(task->tasks_after,count,depafter){ @@ -156,7 +156,7 @@ bool acyclic_graph_detail(xbt_dynar_t dag){ if(child_task->kind == SD_TASK_COMM_E2E){ unsigned int j=0; child_task->marked = 1; - SD_task_t child_task_2 = NULL; + SD_task_t child_task_2 = nullptr; xbt_dynar_foreach(child_task->tasks_after,j,depafter){ child_task_2 = depbefore->dst; if(parents_are_marked(child_task_2)) @@ -166,12 +166,12 @@ bool acyclic_graph_detail(xbt_dynar_t dag){ if(parents_are_marked(child_task)) xbt_dynar_push(next, &child_task); } - child_task = NULL; + child_task = nullptr; } } xbt_dynar_free(¤t); current = next; - next = NULL; + next = nullptr; } xbt_dynar_free(¤t); all_marked = true; @@ -217,13 +217,13 @@ xbt_dynar_t SD_daxload(const char *filename) result = xbt_dynar_new(sizeof(SD_task_t), dax_task_free); files = xbt_dict_new_homogeneous(&dax_task_free); - jobs = xbt_dict_new_homogeneous(NULL); - root_task = SD_task_create_comp_seq("root", NULL, 0); + jobs = xbt_dict_new_homogeneous(nullptr); + root_task = SD_task_create_comp_seq("root", nullptr, 0); /* by design the root task is always SCHEDULABLE */ SD_task_set_state(root_task, SD_SCHEDULABLE); xbt_dynar_push(result, &root_task); - end_task = SD_task_create_comp_seq("end", NULL, 0); + end_task = SD_task_create_comp_seq("end", nullptr, 0); int res = dax_lex(); if (res != 0) @@ -245,16 +245,16 @@ xbt_dynar_t SD_daxload(const char *filename) SD_dependency_t depbefore, depafter; if (xbt_dynar_is_empty(file->tasks_before)) { xbt_dynar_foreach(file->tasks_after, cpt2, depafter) { - newfile = SD_task_create_comm_e2e(file->name, NULL, file->amount); - SD_task_dependency_add(NULL, NULL, root_task, newfile); - SD_task_dependency_add(NULL, NULL, newfile, depafter->dst); + newfile = SD_task_create_comm_e2e(file->name, nullptr, file->amount); + SD_task_dependency_add(nullptr, nullptr, root_task, newfile); + SD_task_dependency_add(nullptr, nullptr, newfile, depafter->dst); xbt_dynar_push(result, &newfile); } } else if (xbt_dynar_is_empty(file->tasks_after)) { xbt_dynar_foreach(file->tasks_before, cpt2, depbefore) { - newfile = SD_task_create_comm_e2e(file->name, NULL, file->amount); - SD_task_dependency_add(NULL, NULL, depbefore->src, newfile); - SD_task_dependency_add(NULL, NULL, newfile, end_task); + newfile = SD_task_create_comm_e2e(file->name, nullptr, file->amount); + SD_task_dependency_add(nullptr, nullptr, depbefore->src, newfile); + SD_task_dependency_add(nullptr, nullptr, newfile, end_task); xbt_dynar_push(result, &newfile); } } else { @@ -265,9 +265,9 @@ xbt_dynar_t SD_daxload(const char *filename) ("File %s is produced and consumed by task %s." "This loop dependency will prevent the execution of the task.", file->name, depbefore->src->name); } - newfile = SD_task_create_comm_e2e(file->name, NULL, file->amount); - SD_task_dependency_add(NULL, NULL, depbefore->src, newfile); - SD_task_dependency_add(NULL, NULL, newfile, depafter->dst); + newfile = SD_task_create_comm_e2e(file->name, nullptr, file->amount); + SD_task_dependency_add(nullptr, nullptr, depbefore->src, newfile); + SD_task_dependency_add(nullptr, nullptr, newfile, depafter->dst); xbt_dynar_push(result, &newfile); } } @@ -288,10 +288,10 @@ xbt_dynar_t SD_daxload(const char *filename) * they don't produce files, connect them to the end node. */ if ((file != root_task) && xbt_dynar_is_empty(file->tasks_before)) { - SD_task_dependency_add(NULL, NULL, root_task, file); + SD_task_dependency_add(nullptr, nullptr, root_task, file); } if ((file != end_task) && xbt_dynar_is_empty(file->tasks_after)) { - SD_task_dependency_add(NULL, NULL, file, end_task); + SD_task_dependency_add(nullptr, nullptr, file, end_task); } } } @@ -303,7 +303,7 @@ xbt_dynar_t SD_daxload(const char *filename) xbt_dynar_foreach(result, cpt, file) SD_task_destroy(file); xbt_dynar_free_container(&result); - return NULL; + return nullptr; } else { return result; } @@ -323,8 +323,8 @@ void STag_dax__job(void) char *name = bprintf("%s@%s", A_dax__job_id, A_dax__job_name); runtime *= 4200000000.; /* Assume that timings were done on a 4.2GFlops machine. I mean, why not? */ // XBT_INFO("See ",A_dax__job_id,A_dax__job_runtime,runtime); - current_job = SD_task_create_comp_seq(name, NULL, runtime); - xbt_dict_set(jobs, A_dax__job_id, current_job, NULL); + current_job = SD_task_create_comp_seq(name, nullptr, runtime); + xbt_dict_set(jobs, A_dax__job_id, current_job, nullptr); free(name); xbt_dynar_push(result, ¤t_job); } @@ -336,19 +336,19 @@ void STag_dax__uses(void) // XBT_INFO("See ",A_dax__uses_file,(is_input?"in":"out")); SD_task_t 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_dynar_pop(sd_global->initial_task_set,NULL); - xbt_dict_set(files, A_dax__uses_file, file, NULL); + if (file == nullptr) { + file = SD_task_create_comm_e2e(A_dax__uses_file, nullptr, size); + xbt_dynar_pop(sd_global->initial_task_set,nullptr); + xbt_dict_set(files, A_dax__uses_file, file, nullptr); } else { if (SD_task_get_amount(file) != size) { XBT_WARN("Ignore file %s size redefinition from %.0f to %.0f", A_dax__uses_file, SD_task_get_amount(file), size); } } if (is_input) { - SD_task_dependency_add(NULL, NULL, file, current_job); + SD_task_dependency_add(nullptr, nullptr, file, current_job); } else { - SD_task_dependency_add(NULL, NULL, current_job, file); + SD_task_dependency_add(nullptr, nullptr, current_job, file); if (xbt_dynar_length(file->tasks_before) > 1) { XBT_WARN("File %s created at more than one location...", file->name); } @@ -359,21 +359,21 @@ static SD_task_t current_child; void STag_dax__child(void) { current_child = (SD_task_t)xbt_dict_get_or_null(jobs, A_dax__child_ref); - xbt_assert(current_child != NULL,"Parse error on line %d: Asked to add dependencies to the non-existent %s task", + xbt_assert(current_child != nullptr,"Parse error on line %d: Asked to add dependencies to the non-existent %s task", dax_lineno, A_dax__child_ref); } void ETag_dax__child(void) { - current_child = NULL; + current_child = nullptr; } void STag_dax__parent(void) { SD_task_t parent = (SD_task_t)xbt_dict_get_or_null(jobs, A_dax__parent_ref); - xbt_assert(parent != NULL, "Parse error on line %d: Asked to add a dependency from %s to %s, but %s does not exist", + xbt_assert(parent != nullptr, "Parse error on line %d: Asked to add a dependency from %s to %s, but %s does not exist", dax_lineno, current_child->name, A_dax__parent_ref, A_dax__parent_ref); - SD_task_dependency_add(NULL, NULL, parent, current_child); + SD_task_dependency_add(nullptr, nullptr, parent, current_child); XBT_DEBUG("Control-flow dependency from %s to %s", current_child->name, parent->name); } @@ -384,7 +384,7 @@ void ETag_dax__adag(void) void ETag_dax__job(void) { - current_job = NULL; + current_job = nullptr; // XBT_INFO("See "); } diff --git a/src/simdag/sd_dotloader.cpp b/src/simdag/sd_dotloader.cpp index fdd429a221..98024df194 100644 --- a/src/simdag/sd_dotloader.cpp +++ b/src/simdag/sd_dotloader.cpp @@ -57,25 +57,25 @@ static int edge_compare(const void *a, const void *b) xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool schedule){ xbt_assert(filename, "Unable to use a null file descriptor\n"); FILE *in_file = fopen(filename, "r"); - xbt_assert(in_file != NULL, "Failed to open file: %s", filename); + xbt_assert(in_file != nullptr, "Failed to open file: %s", filename); unsigned int i; SD_task_t root, end, task; xbt_dict_t computers; - xbt_dynar_t computer = NULL; + xbt_dynar_t computer = nullptr; xbt_dict_cursor_t dict_cursor; bool schedule_success = true; - xbt_dict_t jobs = xbt_dict_new_homogeneous(NULL); + xbt_dict_t jobs = xbt_dict_new_homogeneous(nullptr); xbt_dynar_t result = xbt_dynar_new(sizeof(SD_task_t), dot_task_p_free); Agraph_t * dag_dot = agread(in_file, NIL(Agdisc_t *)); if (schedule) - computers = xbt_dict_new_homogeneous(NULL); + computers = xbt_dict_new_homogeneous(nullptr); /* Create all the nodes */ - Agnode_t *node = NULL; + Agnode_t *node = nullptr; for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) { char *name = agnameof(node); double amount = atof(agget(node, (char *) "size")); @@ -83,14 +83,14 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool if (!(task = (SD_task_t)xbt_dict_get_or_null(jobs, name))) { if (seq_or_par == sequential){ XBT_DEBUG("See ", name, amount); - task = SD_task_create_comp_seq(name, NULL , amount); + task = SD_task_create_comp_seq(name, nullptr , amount); } else { double alpha = atof(agget(node, (char *) "alpha")); XBT_DEBUG("See ", name, amount, alpha); - task = SD_task_create_comp_par_amdahl(name, NULL , amount, alpha); + task = SD_task_create_comp_par_amdahl(name, nullptr , amount, alpha); } - xbt_dict_set(jobs, name, task, NULL); + xbt_dict_set(jobs, name, task, nullptr); if (strcmp(name,"root") && strcmp(name,"end")) xbt_dynar_push(result, &task); @@ -108,8 +108,8 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool /* required parameters are given and less performers than hosts are required */ XBT_DEBUG ("Task '%s' is scheduled on workstation '%d' in position '%d'", task->name, performer, order); if(!(computer = (xbt_dynar_t) xbt_dict_get_or_null(computers, char_performer))){ - computer = xbt_dynar_new(sizeof(SD_task_t), NULL); - xbt_dict_set(computers, char_performer, computer, NULL); + computer = xbt_dynar_new(sizeof(SD_task_t), nullptr); + xbt_dict_set(computers, char_performer, computer, nullptr); } if((unsigned int)order < xbt_dynar_length(computer)){ @@ -137,18 +137,18 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool /*Check if 'root' and 'end' nodes have been explicitly declared. If not, create them. */ if (!(root = (SD_task_t)xbt_dict_get_or_null(jobs, "root"))) - root = (seq_or_par == sequential?SD_task_create_comp_seq("root", NULL, 0): - SD_task_create_comp_par_amdahl("root", NULL, 0, 0)); + root = (seq_or_par == sequential?SD_task_create_comp_seq("root", nullptr, 0): + SD_task_create_comp_par_amdahl("root", nullptr, 0, 0)); SD_task_set_state(root, SD_SCHEDULABLE); /* by design the root task is always SCHEDULABLE */ xbt_dynar_insert_at(result, 0, &root); /* Put it at the beginning of the dynar */ if (!(end = (SD_task_t)xbt_dict_get_or_null(jobs, "end"))) - end = (seq_or_par == sequential?SD_task_create_comp_seq("end", NULL, 0): - SD_task_create_comp_par_amdahl("end", NULL, 0, 0)); + end = (seq_or_par == sequential?SD_task_create_comp_seq("end", nullptr, 0): + SD_task_create_comp_par_amdahl("end", nullptr, 0, 0)); /* Create edges */ - xbt_dynar_t edges = xbt_dynar_new(sizeof(Agedge_t*), NULL); + xbt_dynar_t edges = xbt_dynar_new(sizeof(Agedge_t*), nullptr); for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) { Agedge_t * edge; xbt_dynar_reset(edges); @@ -171,19 +171,19 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool XBT_DEBUG("See ", name, size); if (!(task = (SD_task_t)xbt_dict_get_or_null(jobs, name))) { if (seq_or_par == sequential) - task = SD_task_create_comm_e2e(name, NULL , size); + task = SD_task_create_comm_e2e(name, nullptr , size); else - task = SD_task_create_comm_par_mxn_1d_block(name, NULL , size); - SD_task_dependency_add(NULL, NULL, src, task); - SD_task_dependency_add(NULL, NULL, task, dst); - xbt_dict_set(jobs, name, task, NULL); + task = SD_task_create_comm_par_mxn_1d_block(name, nullptr , size); + SD_task_dependency_add(nullptr, nullptr, src, task); + SD_task_dependency_add(nullptr, nullptr, task, dst); + xbt_dict_set(jobs, name, task, nullptr); xbt_dynar_push(result, &task); } else { XBT_WARN("Task '%s' is defined more than once", name); } xbt_free(name); } else { - SD_task_dependency_add(NULL, NULL, src, dst); + SD_task_dependency_add(nullptr, nullptr, src, dst); } } } @@ -196,12 +196,12 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool xbt_dynar_foreach (result, i, task){ if (xbt_dynar_is_empty(task->tasks_before) && task != root) { XBT_DEBUG("Task '%s' has no source. Add dependency from 'root'", task->name); - SD_task_dependency_add(NULL, NULL, root, task); + SD_task_dependency_add(nullptr, nullptr, root, task); } if (xbt_dynar_is_empty(task->tasks_after) && task != end) { XBT_DEBUG("Task '%s' has no destination. Add dependency to 'end'", task->name); - SD_task_dependency_add(NULL, NULL, task, end); + SD_task_dependency_add(nullptr, nullptr, task, end); } } @@ -214,12 +214,12 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool if (schedule_success) { const sg_host_t *workstations = sg_host_list (); xbt_dict_foreach(computers,dict_cursor,computer_name,computer){ - SD_task_t previous_task = NULL; + SD_task_t previous_task = nullptr; xbt_dynar_foreach(computer, i, task){ /* add dependency between the previous and the task to avoid parallel execution */ if(task){ if(previous_task && !SD_task_dependency_exists(previous_task, task)) - SD_task_dependency_add(NULL, NULL, previous_task, task); + SD_task_dependency_add(nullptr, nullptr, previous_task, task); SD_task_schedulel(task, 1, workstations[atoi(computer_name)]); previous_task = task; @@ -234,7 +234,7 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool xbt_dynar_free(&computer); xbt_dict_free(&computers); xbt_dynar_free(&result); - result = NULL; + result = nullptr; } } @@ -243,7 +243,7 @@ xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par, bool XBT_ERROR("The DOT described in %s is not a DAG. It contains a cycle.", base); free(base); xbt_dynar_free(&result); - result = NULL; + result = nullptr; } return result; } diff --git a/src/simdag/sd_global.cpp b/src/simdag/sd_global.cpp index c974b63849..fa37ca6670 100644 --- a/src/simdag/sd_global.cpp +++ b/src/simdag/sd_global.cpp @@ -18,7 +18,7 @@ XBT_LOG_NEW_CATEGORY(sd, "Logging specific to SimDag"); XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_kernel, sd, "Logging specific to SimDag (kernel)"); -SD_global_t sd_global = NULL; +SD_global_t sd_global = nullptr; /** * \brief Initializes SD internal data @@ -33,17 +33,17 @@ void SD_init(int *argc, char **argv) { TRACE_global_init(argc, argv); - xbt_assert(sd_global == NULL, "SD_init() already called"); + xbt_assert(sd_global == nullptr, "SD_init() already called"); sd_global = xbt_new(s_SD_global_t, 1); sd_global->watch_point_reached = 0; sd_global->task_mallocator=xbt_mallocator_new(65536, SD_task_new_f, SD_task_free_f, SD_task_recycle_f); - sd_global->initial_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL); - sd_global->executable_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL); - sd_global->completed_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL); - sd_global->return_set = xbt_dynar_new(sizeof(SD_task_t), NULL); + sd_global->initial_task_set = xbt_dynar_new(sizeof(SD_task_t), nullptr); + sd_global->executable_task_set = xbt_dynar_new(sizeof(SD_task_t), nullptr); + sd_global->completed_task_set = xbt_dynar_new(sizeof(SD_task_t), nullptr); + sd_global->return_set = xbt_dynar_new(sizeof(SD_task_t), nullptr); surf_init(argc, argv); @@ -140,7 +140,7 @@ xbt_dynar_t SD_simulate(double how_long) { double elapsed_time = 0.0; while (elapsed_time >= 0.0 && (how_long < 0.0 || 0.00001 < (how_long -total_time)) && !sd_global->watch_point_reached) { - surf_model_t model = NULL; + surf_model_t model = nullptr; XBT_DEBUG("Total time: %f", total_time); @@ -159,7 +159,7 @@ xbt_dynar_t SD_simulate(double how_long) { XBT_VERB("Task '%s' done", SD_task_get_name(task)); SD_task_set_state(task, SD_DONE); task->surf_action->unref(); - task->surf_action = NULL; + task->surf_action = nullptr; /* the state has changed. Add it only if it's the first change */ if (xbt_dynar_member(sd_global->return_set, &task) == 0) { @@ -221,7 +221,7 @@ xbt_dynar_t SD_simulate(double how_long) { XBT_VERB("Task '%s' failed", SD_task_get_name(task)); SD_task_set_state(task, SD_FAILED); action->unref(); - task->surf_action = NULL; + task->surf_action = nullptr; xbt_dynar_push(sd_global->return_set, &task); } @@ -273,5 +273,5 @@ void SD_exit() xbt_dynar_free_container(&(sd_global->completed_task_set)); xbt_dynar_free_container(&(sd_global->return_set)); xbt_free(sd_global); - sd_global = NULL; + sd_global = nullptr; } diff --git a/src/simdag/sd_task.cpp b/src/simdag/sd_task.cpp index 347abaaef8..2e92697396 100644 --- a/src/simdag/sd_task.cpp +++ b/src/simdag/sd_task.cpp @@ -43,15 +43,15 @@ static void __SD_task_destroy_scheduling_data(SD_task_t task) xbt_free(task->flops_amount); xbt_free(task->bytes_amount); - task->flops_amount = NULL; - task->bytes_amount = NULL; + task->flops_amount = nullptr; + task->bytes_amount = nullptr; } void* SD_task_new_f() { SD_task_t task = xbt_new0(s_SD_task_t, 1); - task->tasks_before = xbt_dynar_new(sizeof(SD_dependency_t), NULL); - task->tasks_after = xbt_dynar_new(sizeof(SD_dependency_t), NULL); + task->tasks_before = xbt_dynar_new(sizeof(SD_dependency_t), nullptr); + task->tasks_after = xbt_dynar_new(sizeof(SD_dependency_t), nullptr); return task; } @@ -69,7 +69,7 @@ void SD_task_recycle_f(void *t) task->start_time = -1.0; task->finish_time = -1.0; - task->surf_action = NULL; + task->surf_action = nullptr; task->watch_points = 0; /* dependencies */ @@ -80,9 +80,9 @@ void SD_task_recycle_f(void *t) /* scheduling parameters */ task->host_count = 0; - task->host_list = NULL; - task->flops_amount = NULL; - task->bytes_amount = NULL; + task->host_list = nullptr; + task->flops_amount = nullptr; + task->bytes_amount = nullptr; task->rate = -1; } @@ -98,8 +98,8 @@ void SD_task_free_f(void *t) /** * \brief Creates a new task. * - * \param name the name of the task (can be \c NULL) - * \param data the user data you want to associate with the task (can be \c NULL) + * \param name the name of the task (can be \c nullptr) + * \param data the user data you want to associate with the task (can be \c nullptr) * \param amount amount of the task * \return the new task * \see SD_task_destroy() @@ -153,8 +153,8 @@ SD_task_t SD_task_create_comm_e2e(const char *name, void *data, double amount) * * A sequential computation must be scheduled on 1 host, and the amount specified at creation to be run on hosts[0]. * - * \param name the name of the task (can be \c NULL) - * \param data the user data you want to associate with the task (can be \c NULL) + * \param name the name of the task (can be \c nullptr) + * \param data the user data you want to associate with the task (can be \c nullptr) * \param flops_amount amount of compute work to be done by the task * \return the new SD_TASK_COMP_SEQ typed task */ @@ -176,8 +176,8 @@ SD_task_t SD_task_create_comp_seq(const char *name, void *data, double flops_amo * A parallel computation can be scheduled on any number of host. * The underlying speedup model is Amdahl's law. * To be auto-scheduled, \see SD_task_distribute_comp_amdahl has to be called first. - * \param name the name of the task (can be \c NULL) - * \param data the user data you want to associate with the task (can be \c NULL) + * \param name the name of the task (can be \c nullptr) + * \param data the user data you want to associate with the task (can be \c nullptr) * \param flops_amount amount of compute work to be done by the task * \param alpha purely serial fraction of the work to be done (in [0.;1.[) * \return the new task @@ -202,15 +202,15 @@ SD_task_t SD_task_create_comp_par_amdahl(const char *name, void *data, double fl * A data redistribution can be scheduled on any number of host. * The assumed distribution is a 1D block distribution. Each host owns the same share of the \see amount. * To be auto-scheduled, \see SD_task_distribute_comm_mxn_1d_block has to be called first. - * \param name the name of the task (can be \c NULL) - * \param data the user data you want to associate with the task (can be \c NULL) + * \param name the name of the task (can be \c nullptr) + * \param data the user data you want to associate with the task (can be \c nullptr) * \param amount amount of data to redistribute by the task * \return the new task */ SD_task_t SD_task_create_comm_par_mxn_1d_block(const char *name, void *data, double amount) { SD_task_t res = SD_task_create(name, data, amount); - res->host_list=NULL; + res->host_list=nullptr; res->kind = SD_TASK_COMM_PAR_MXN_1D_BLOCK; return res; @@ -235,12 +235,12 @@ void SD_task_destroy(SD_task_t task) int idx = xbt_dynar_search_or_negative(sd_global->return_set, &task); if (idx >=0) { - xbt_dynar_remove_at(sd_global->return_set, idx, NULL); + xbt_dynar_remove_at(sd_global->return_set, idx, nullptr); } xbt_free(task->name); - if (task->surf_action != NULL) + if (task->surf_action != nullptr) task->surf_action->unref(); xbt_free(task->host_list); @@ -256,7 +256,7 @@ void SD_task_destroy(SD_task_t task) * \brief Returns the user data of a task * * \param task a task - * \return the user data associated with this task (can be \c NULL) + * \return the user data associated with this task (can be \c nullptr) * \see SD_task_set_data() */ void *SD_task_get_data(SD_task_t task) @@ -267,8 +267,8 @@ void *SD_task_get_data(SD_task_t task) /** * \brief Sets the user data of a task * - * The new data can be \c NULL. The old data should have been freed first - * if it was not \c NULL. + * The new data can be \c nullptr. The old data should have been freed first + * if it was not \c nullptr. * * \param task a task * \param data the new data you want to associate with this task @@ -325,27 +325,27 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state) case SD_SCHEDULABLE: if (SD_task_get_state(task) == SD_FAILED){ xbt_dynar_remove_at(sd_global->completed_task_set, - xbt_dynar_search(sd_global->completed_task_set, &task), NULL); + xbt_dynar_search(sd_global->completed_task_set, &task), nullptr); xbt_dynar_push(sd_global->initial_task_set,&task); } break; case SD_SCHEDULED: if (SD_task_get_state(task) == SD_RUNNABLE){ xbt_dynar_remove_at(sd_global->executable_task_set, - xbt_dynar_search(sd_global->executable_task_set, &task), NULL); + xbt_dynar_search(sd_global->executable_task_set, &task), nullptr); xbt_dynar_push(sd_global->initial_task_set,&task); } break; case SD_RUNNABLE: idx = xbt_dynar_search_or_negative(sd_global->initial_task_set, &task); if (idx >= 0) { - xbt_dynar_remove_at(sd_global->initial_task_set, idx, NULL); + xbt_dynar_remove_at(sd_global->initial_task_set, idx, nullptr); xbt_dynar_push(sd_global->executable_task_set,&task); } break; case SD_RUNNING: xbt_dynar_remove_at(sd_global->executable_task_set, - xbt_dynar_search(sd_global->executable_task_set, &task), NULL); + xbt_dynar_search(sd_global->executable_task_set, &task), nullptr); break; case SD_DONE: xbt_dynar_push(sd_global->completed_task_set,&task); @@ -375,7 +375,7 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state) * \brief Returns the name of a task * * \param task a task - * \return the name of this task (can be \c NULL) + * \return the name of this task (can be \c nullptr) */ const char *SD_task_get_name(SD_task_t task) { @@ -400,7 +400,7 @@ xbt_dynar_t SD_task_get_parents(SD_task_t task) unsigned int i; SD_dependency_t dep; - xbt_dynar_t parents = xbt_dynar_new(sizeof(SD_task_t), NULL); + xbt_dynar_t parents = xbt_dynar_new(sizeof(SD_task_t), nullptr); xbt_dynar_foreach(task->tasks_before, i, dep) { xbt_dynar_push(parents, &(dep->src)); } @@ -417,7 +417,7 @@ xbt_dynar_t SD_task_get_children(SD_task_t task) unsigned int i; SD_dependency_t dep; - xbt_dynar_t children = xbt_dynar_new(sizeof(SD_task_t), NULL); + xbt_dynar_t children = xbt_dynar_new(sizeof(SD_task_t), nullptr); xbt_dynar_foreach(task->tasks_after, i, dep) { xbt_dynar_push(children, &(dep->dst)); } @@ -596,8 +596,8 @@ void SD_task_dotty(SD_task_t task, void *out) * \a dst will depend on \a src, ie \a dst will not start before \a src is finished. * Their \ref e_SD_task_state_t "state" must be #SD_NOT_SCHEDULED, #SD_SCHEDULED or #SD_RUNNABLE. * - * \param name the name of the new dependency (can be \c NULL) - * \param data the user data you want to associate with this dependency (can be \c NULL) + * \param name the name of the new dependency (can be \c nullptr) + * \param data the user data you want to associate with this dependency (can be \c nullptr) * \param src the task which must be executed first * \param dst the task you want to make depend on \a src * \see SD_task_dependency_remove() @@ -636,7 +636,7 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task dependency = xbt_new(s_SD_dependency_t, 1); - dependency->name = xbt_strdup(name); /* xbt_strdup is cleaver enough to deal with NULL args itself */ + dependency->name = xbt_strdup(name); /* xbt_strdup is cleaver enough to deal with nullptr args itself */ dependency->data = data; dependency->src = src; dependency->dst = dst; @@ -670,7 +670,7 @@ const char *SD_task_dependency_get_name(SD_task_t src, SD_task_t dst) if (dependency->dst == dst) return dependency->name; } - return NULL; + return nullptr; } /** @@ -679,12 +679,12 @@ const char *SD_task_dependency_get_name(SD_task_t src, SD_task_t dst) * \param src a task * \param dst a task depending on \a src * - * If src is NULL, checks whether dst has any pre-dependency. - * If dst is NULL, checks whether src has any post-dependency. + * If src is nullptr, checks whether dst has any pre-dependency. + * If dst is nullptr, checks whether src has any post-dependency. */ int SD_task_dependency_exists(SD_task_t src, SD_task_t dst) { - xbt_assert(src != NULL || dst != NULL, "Invalid parameter: both src and dst are NULL"); + xbt_assert(src != nullptr || dst != nullptr, "Invalid parameter: both src and dst are nullptr"); if (src) { if (dst) { @@ -722,7 +722,7 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) for (unsigned long i = 0; i < length && !found; i++) { xbt_dynar_get_cpy(src->tasks_after, i, &dependency); if (dependency->dst == dst) { - xbt_dynar_remove_at(src->tasks_after, i, NULL); + xbt_dynar_remove_at(src->tasks_after, i, nullptr); found = true; } } @@ -737,7 +737,7 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) for (unsigned long i = 0; i < length && !found; i++) { xbt_dynar_get_cpy(dst->tasks_before, i, &dependency); if (dependency->src == src) { - xbt_dynar_remove_at(dst->tasks_before, i, NULL); + xbt_dynar_remove_at(dst->tasks_before, i, nullptr); __SD_task_dependency_destroy(dependency); dst->unsatisfied_dependencies--; dst->is_not_ready--; @@ -765,7 +765,7 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) * * \param src a task * \param dst a task depending on \a src - * \return the user data associated with this dependency (can be \c NULL) + * \return the user data associated with this dependency (can be \c nullptr) * \see SD_task_dependency_add() */ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) @@ -838,10 +838,10 @@ double SD_task_get_execution_time(SD_task_t task, int workstation_nb, const sg_h /* the task execution time is the maximum execution time of the parallel tasks */ for (int i = 0; i < workstation_nb; i++) { double time = 0.0; - if (flops_amount != NULL) + if (flops_amount != nullptr) time = flops_amount[i] / workstation_list[i]->speed(); - if (bytes_amount != NULL) + if (bytes_amount != nullptr) for (int j = 0; j < workstation_nb; j++) { if (bytes_amount[i * workstation_nb + j] !=0 ) { time += (SD_route_get_latency(workstation_list[i], workstation_list[j]) + @@ -895,7 +895,7 @@ void SD_task_schedule(SD_task_t task, int host_count, const sg_host_t * workstat memcpy(task->flops_amount, flops_amount, sizeof(double) * host_count); } else { xbt_free(task->flops_amount); - task->flops_amount = NULL; + task->flops_amount = nullptr; } int communication_nb = host_count * host_count; @@ -904,7 +904,7 @@ void SD_task_schedule(SD_task_t task, int host_count, const sg_host_t * workstat memcpy(task->bytes_amount, bytes_amount, sizeof(double) * communication_nb); } else { xbt_free(task->bytes_amount); - task->bytes_amount = NULL; + task->bytes_amount = nullptr; } task->host_list = static_cast(xbt_realloc(task->host_list, sizeof(sg_host_t) * host_count)); @@ -936,7 +936,7 @@ void SD_task_unschedule(SD_task_t task) /* Don't free scheduling data for typed tasks */ __SD_task_destroy_scheduling_data(task); xbt_free(task->host_list); - task->host_list=NULL; + task->host_list=nullptr; task->host_count = 0; } @@ -958,7 +958,7 @@ void SD_task_run(SD_task_t task) { xbt_assert(SD_task_get_state(task) == SD_RUNNABLE, "Task '%s' is not runnable! Task state: %d", SD_task_get_name(task), (int)SD_task_get_state(task)); - xbt_assert(task->host_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task)); + xbt_assert(task->host_list != nullptr, "Task '%s': workstation_list is nullptr!", SD_task_get_name(task)); XBT_DEBUG("Running task '%s'", SD_task_get_name(task)); diff --git a/src/simdag/sd_workstation.cpp b/src/simdag/sd_workstation.cpp index 5241965829..ceeb8c1334 100644 --- a/src/simdag/sd_workstation.cpp +++ b/src/simdag/sd_workstation.cpp @@ -21,7 +21,7 @@ SD_link_t *SD_route_get_list(sg_host_t src, sg_host_t dst) { std::vector *route = new std::vector(); - routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard, route, NULL); + routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard, route, nullptr); int cpt=0; SD_link_t *list = xbt_new(SD_link_t, route->size()); @@ -43,7 +43,7 @@ SD_link_t *SD_route_get_list(sg_host_t src, sg_host_t dst) int SD_route_get_size(sg_host_t src, sg_host_t dst) { std::vector *route = new std::vector(); - routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard, route, NULL); + routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard, route, nullptr); int size = route->size(); delete route; return size; @@ -81,7 +81,7 @@ double SD_route_get_bandwidth(sg_host_t src, sg_host_t dst) double min_bandwidth = -1.0; std::vector *route = new std::vector(); - routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard, route, NULL); + routing_platf->getRouteAndLatency(src->pimpl_netcard, dst->pimpl_netcard, route, nullptr); for (auto link : *route) { double bandwidth = sg_link_bandwidth(link); -- 2.20.1