X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/84ebf8af3c606445e30b013b2e14bebeaa693dbf..0e9c0448c6566825b170b98ecff716b098bda10e:/src/simdag/sd_dotloader.c diff --git a/src/simdag/sd_dotloader.c b/src/simdag/sd_dotloader.c index cb9108cd02..f635a0fbde 100644 --- a/src/simdag/sd_dotloader.c +++ b/src/simdag/sd_dotloader.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2009, 2010. The SimGrid Team. +/* Copyright (c) 2009-2013. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -8,57 +8,56 @@ #include "simdag/simdag.h" #include "xbt/misc.h" #include "xbt/log.h" +#include +#include +#include -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_dotparse, sd,"Parsing DOT files"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_dotparse, sd, "Parsing DOT files"); #undef CLEANUP -#include -void dot_add_task(Agnode_t *dag_node) ; -void dot_add_input_dependencies(SD_task_t current_job, Agedge_t *edge) ; -void dot_add_output_dependencies(SD_task_t current_job, Agedge_t *edge) ; -xbt_dynar_t SD_dotload_FILE(FILE* in_file); +#ifdef HAVE_CGRAPH_H +#include +#elif HAVE_AGRAPH_H +#include +#define agnxtnode(dot, node) agnxtnode(node) +#define agfstin(dot, node) agfstin(node) +#define agnxtin(dot, edge) agnxtin(edge) +#define agfstout(dot, node) agfstout(node) +#define agnxtout(dot, edge) agnxtout(edge) +#endif -static double dot_parse_double(const char *string) { - if (string == NULL) return -10; - int ret = 0; - double value; +typedef enum { + sequential =0, + parallel +} seq_par_t; - ret = sscanf(string, "%lg", &value); - if (ret != 1) - WARN1("%s is not a double", string); - return value; -} -static int dot_parse_int(const char *string) { - if (string == NULL) return -10; - int ret = 0; - int value; - - ret = sscanf(string, "%d", &value); - if (ret != 1) - WARN1("%s is not an integer", string); - return value; -} +xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par); static xbt_dynar_t result; static xbt_dict_t jobs; -static xbt_dict_t files; -static SD_task_t root_task,end_task; -static Agraph_t * dag_dot; - -static void dump_res() { - unsigned int cursor; - SD_task_t task; - xbt_dynar_foreach(result,cursor,task) { - INFO1("Task %d",cursor); - SD_task_dump(task); - } +static xbt_dict_t computers; +static Agraph_t *dag_dot; +static bool schedule = true; + +static void dot_task_p_free(void *task) { + SD_task_t *t = task; + SD_task_destroy(*t); } -static void dot_task_free(void*task){ - SD_task_t t=task; - SD_task_destroy(t); +#ifdef HAVE_TRACING +static void TRACE_sd_dotloader (SD_task_t task, const char *category) { + if (category && strlen (category)){ + if (task->category) + XBT_DEBUG("Change the category of %s from %s to %s", + task->name, task->category, category); + else + XBT_DEBUG("Set the category of %s to %s",task->name, category); + TRACE_category (category); + TRACE_sd_set_task_category(task, category); + } } +#endif /** @brief loads a DOT file describing a DAG * @@ -69,200 +68,322 @@ static void dot_task_free(void*task){ * (the amount of data transfer in bit). * if they aren't here, there choose to be equal to zero. */ -xbt_dynar_t SD_dotload(const char*filename){ - FILE* in_file = fopen(filename,"r"); - xbt_assert1(in_file, "Unable to open \"%s\"\n", filename); - SD_dotload_FILE(in_file); - fclose(in_file); - return result; +xbt_dynar_t SD_dotload(const char *filename) { + computers = xbt_dict_new_homogeneous(NULL); + schedule = false; + SD_dotload_generic(filename, sequential); + xbt_dynar_t computer = NULL; + xbt_dict_cursor_t dict_cursor; + char *computer_name; + xbt_dict_foreach(computers,dict_cursor,computer_name,computer){ + xbt_dynar_free(&computer); + } + xbt_dict_free(&computers); + return result; } -xbt_dynar_t SD_dotload_FILE(FILE* in_file){ - xbt_assert0(in_file, "Unable to use a null file descriptor\n"); - dag_dot = agread(in_file,NIL(Agdisc_t*)); +xbt_dynar_t SD_dotload_with_sched(const char *filename) { + computers = xbt_dict_new_homogeneous(NULL); + SD_dotload_generic(filename, sequential); - result = xbt_dynar_new(sizeof(SD_task_t),dot_task_free); - files=xbt_dict_new(); - jobs=xbt_dict_new(); - root_task = SD_task_create_comp_seq("root",NULL,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); - - Agnode_t *dag_node = NULL; - for (dag_node = agfstnode(dag_dot); dag_node; dag_node = agnxtnode(dag_dot,dag_node)){ - dot_add_task(dag_node); - } - agclose(dag_dot); - xbt_dict_free(&jobs); - - /* And now, post-process the files. - * We want a file task per pair of computation tasks exchanging the file. Duplicate on need - * Files not produced in the system are said to be produced by root task (top of DAG). - * Files not consumed in the system are said to be consumed by end task (bottom of DAG). - */ - xbt_dict_cursor_t cursor; - SD_task_t file; - char *name; - xbt_dict_foreach(files,cursor,name,file) { - unsigned int cpt1,cpt2; - SD_task_t newfile = NULL; - SD_dependency_t depbefore,depafter; - if (xbt_dynar_length(file->tasks_before) == 0) { - xbt_dynar_foreach(file->tasks_after,cpt2,depafter) { - SD_task_t 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); - xbt_dynar_push(result,&newfile); - } - } else if (xbt_dynar_length(file->tasks_after) == 0) { - xbt_dynar_foreach(file->tasks_before,cpt2,depbefore) { - SD_task_t 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); - xbt_dynar_push(result,&newfile); - } - } else { - xbt_dynar_foreach(file->tasks_before,cpt1,depbefore) { - xbt_dynar_foreach(file->tasks_after,cpt2,depafter) { - if (depbefore->src == depafter->dst) { - WARN2("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); - xbt_dynar_push(result,&newfile); - } - } + if(schedule){ + xbt_dynar_t computer = NULL; + xbt_dict_cursor_t dict_cursor; + char *computer_name; + const SD_workstation_t *workstations = SD_workstation_get_list (); + xbt_dict_foreach(computers,dict_cursor,computer_name,computer){ + int count_computer = atoi(computer_name); + unsigned int count=0; + SD_task_t task; + SD_task_t task_previous = NULL; + xbt_dynar_foreach(computer,count,task){ + /* add dependency between the previous and the task to avoid + * parallel execution */ + if(task != NULL ){ + if(task_previous != NULL && + !SD_task_dependency_exists(task_previous, task)) + SD_task_dependency_add(NULL, NULL, task_previous, task); + SD_task_schedulel(task, 1, workstations[count_computer]); + task_previous = task; } + } + xbt_dynar_free(&computer); } + xbt_dict_free(&computers); + if(acyclic_graph_detail(result)) + return result; + else + XBT_WARN("There is at least one cycle in the provided task graph"); + }else{ + XBT_WARN("The scheduling is ignored"); + } + xbt_dynar_t computer = NULL; + xbt_dict_cursor_t dict_cursor; + char *computer_name; + xbt_dict_foreach(computers,dict_cursor,computer_name,computer){ + xbt_dynar_free(&computer); + } + xbt_dict_free(&computers); + xbt_dynar_free(&result); + return NULL; +} - /* Push end task last */ - xbt_dynar_push(result,&end_task); - - /* Free previous copy of the files */ - xbt_dict_free(&files); +xbt_dynar_t SD_PTG_dotload(const char * filename) { + xbt_dynar_t result = SD_dotload_generic(filename, parallel); + if (!acyclic_graph_detail(result)) { + XBT_ERROR("The DOT described in %s is not a DAG. It contains a cycle.", + basename((char*)filename)); + xbt_dynar_free(&result); + /* (result == NULL) here */ + } + return result; +} - return result; +#ifdef HAVE_CGRAPH_H +static int edge_compare(const void *a, const void *b) +{ + unsigned va = AGSEQ(*(Agedge_t **)a); + unsigned vb = AGSEQ(*(Agedge_t **)b); + return va == vb ? 0 : (va < vb ? -1 : 1); } +#endif -/* dot_add_task create a sd_task and all transfers required for this - * task. The execution time of the task is given by the attribute size. - * The unit of size is the Flop.*/ -void dot_add_task(Agnode_t *dag_node) { - char *name = agnameof(dag_node); - double runtime = dot_parse_double(agget(dag_node,(char*)"size")); - long performer = (long)dot_parse_int((char *) agget(dag_node,(char*)"performer")); - INFO3("See ",name,agget(dag_node,(char*)"size"),runtime); - SD_task_t current_job = SD_task_create_comp_seq(name,(void*)performer,runtime); - xbt_dict_set(jobs,name,current_job,NULL); - xbt_dynar_push(result,¤t_job); - Agedge_t *e; - int count = 0; - for (e = agfstin(dag_dot,dag_node); e; e = agnxtin(dag_dot,e)) { - dot_add_input_dependencies(current_job,e); - count++; - } - if (count==0){ - SD_task_t file; - char *name= (char*)"root->many"; - double size = 0; - - file = xbt_dict_get_or_null(files,name); - if (file==NULL) { - file = SD_task_create_comm_e2e(name,NULL,size); - xbt_dict_set(files,name,file,&dot_task_free); - } else { - if (SD_task_get_amount(file)!=size) { - WARN3("Ignoring file %s size redefinition from %.0f to %.0f", - name,SD_task_get_amount(file),size); - } +xbt_dynar_t SD_dotload_generic(const char * filename, seq_par_t seq_or_par){ + xbt_assert(filename, "Unable to use a null file descriptor\n"); + unsigned int i; + result = xbt_dynar_new(sizeof(SD_task_t), dot_task_p_free); + jobs = xbt_dict_new_homogeneous(NULL); + FILE *in_file = fopen(filename, "r"); + if (in_file == NULL) + xbt_die("Failed to open file: %s", filename); + dag_dot = agread(in_file, NIL(Agdisc_t *)); + SD_task_t root, end, task; + /* + * Create all the nodes + */ + Agnode_t *node = NULL; + for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) { + + char *name = agnameof(node); + double amount = atof(agget(node, (char *) "size")); + double alpha = 0.0; + + if (seq_or_par == sequential){ + XBT_DEBUG("See ", name, amount); + } else { + if (!strcmp(agget(node, (char *) "alpha"), "")){ + alpha = atof(agget(node, (char *) "alpha")); + if (alpha == -1.){ + XBT_DEBUG("negative alpha value provided. Set to 0."); + alpha = 0.0 ; } - SD_task_dependency_add(NULL,NULL,file,current_job); - } - count = 0; - for (e = agfstout(dag_dot,dag_node); e; e = agnxtout(dag_dot,e)) { - dot_add_output_dependencies(current_job,e); - count++; + } else { + XBT_DEBUG("no alpha value provided. Set to 0"); + alpha = 0.0 ; + } + + XBT_DEBUG("See ", + name, amount, alpha); } - if (count==0){ - SD_task_t file; - char *name = (char*)"many->end"; - double size = 0; - - // INFO2("See ",A_dot__uses_file,(is_input?"in":"out")); - file = xbt_dict_get_or_null(files,name); - if (file==NULL) { - file = SD_task_create_comm_e2e(name,NULL,size); - xbt_dict_set(files,name,file,&dot_task_free); + + if (!(task = xbt_dict_get_or_null(jobs, name))) { + if (seq_or_par == sequential){ + task = SD_task_create_comp_seq(name, NULL , amount); + } else { + task = SD_task_create_comp_par_amdahl(name, NULL , amount, alpha); + } +#ifdef HAVE_TRACING + TRACE_sd_dotloader (task, agget (node, (char*)"category")); +#endif + xbt_dict_set(jobs, name, task, NULL); + if (!strcmp(name, "root")){ + /* by design the root task is always SCHEDULABLE */ + __SD_task_set_state(task, SD_SCHEDULABLE); + /* Put it at the beginning of the dynar */ + xbt_dynar_insert_at(result, 0, &task); + } else { + if (!strcmp(name, "end")){ + XBT_DEBUG("Declaration of the 'end' node, don't store it yet."); + end = task; + /* Should be inserted later in the dynar */ } else { - if (SD_task_get_amount(file)!=size) { - WARN3("Ignoring file %s size redefinition from %.0f to %.0f", - name,SD_task_get_amount(file),size); + xbt_dynar_push(result, &task); + } + } + + if((seq_or_par == sequential) && + (schedule || + XBT_LOG_ISENABLED(sd_dotparse, xbt_log_priority_verbose))){ + /* try to take the information to schedule the task only if all is + * right*/ + int performer, order; + char *char_performer = agget(node, (char *) "performer"); + char *char_order = agget(node, (char *) "order"); + /* performer is the computer which execute the task */ + performer = + ((!char_performer || !strcmp(char_performer,"")) ? -1:atoi(char_performer)); + /* order is giving the task order on one computer */ + order = ((!char_order || !strcmp(char_order, ""))? -1:atoi(char_order)); + + XBT_DEBUG ("Task '%s' is scheduled on workstation '%d' in position '%d'", + task->name, performer, order); + xbt_dynar_t computer = NULL; + if(performer != -1 && order != -1){ + /* required parameters are given */ + computer = xbt_dict_get_or_null(computers, char_performer); + if(computer == NULL){ + computer = xbt_dynar_new(sizeof(SD_task_t), NULL); + xbt_dict_set(computers, char_performer, computer, NULL); + } + if(performer < xbt_lib_length(host_lib)){ + /* the wanted computer is available */ + SD_task_t *task_test = NULL; + if(order < computer->used) + task_test = xbt_dynar_get_ptr(computer,order); + if(task_test != NULL && *task_test != NULL && *task_test != task){ + /* the user gives the same order to several tasks */ + schedule = false; + XBT_VERB("The task %s starts on the computer %s at the position : %s like the task %s", + (*task_test)->name, char_performer, char_order, + task->name); + }else{ + /* the parameter seems to be ok */ + xbt_dynar_set_as(computer, order, SD_task_t, task); } + }else{ + /* the platform has not enough processors to schedule the DAG like + * the user wants*/ + schedule = false; + XBT_VERB("The schedule is ignored, there are not enough computers"); + } } - SD_task_dependency_add(NULL,NULL,current_job,file); - if (xbt_dynar_length(file->tasks_before)>1) { - WARN1("File %s created at more than one location...",file->name); + else { + /* one of required parameters is not given */ + schedule = false; + XBT_VERB("The schedule is ignored, the task %s is not correctly scheduled", + task->name); } - } -} - -/* dot_add_output_dependencies create the dependencies between a task - * and a transfers. This is given by the edges in the dot file. - * The amount of data transfers is given by the attribute size on the - * edge. */ -void dot_add_input_dependencies(SD_task_t current_job, Agedge_t *edge) { - SD_task_t file; - - char name[80]; - sprintf(name ,"%s->%s",agnameof(agtail(edge)) ,agnameof(aghead(edge))); - double size = dot_parse_double(agget(edge,(char*)"size")); - //int sender = dot_parse_int(agget(edge,(char*)"sender")); - //int reciever = dot_parse_int(agget(edge,(char*)"reciever")); - - file = xbt_dict_get_or_null(files,name); - if (file==NULL) { - file = SD_task_create_comm_e2e(name,NULL,size); - xbt_dict_set(files,name,file,&dot_task_free); + } } else { - if (SD_task_get_amount(file)!=size) { - WARN3("Ignoring file %s size redefinition from %.0f to %.0f", - name,SD_task_get_amount(file),size); - } + XBT_WARN("Task '%s' is defined more than once", name); } - SD_task_dependency_add(NULL,NULL,file,current_job); -} + } -/* dot_add_output_dependencies create the dependencies between a - * transfers and a task. This is given by the edges in the dot file. - * The amount of data transfers is given by the attribute size on the - * edge. */ -void dot_add_output_dependencies(SD_task_t current_job, Agedge_t *edge) { - SD_task_t file; - char name[80]; - sprintf(name ,"%s->%s",agnameof(agtail(edge)) ,agnameof(aghead(edge))); - double size = dot_parse_double(agget(edge,(char*)"size")); - //int sender = dot_parse_int(agget(edge,(char*)"sender")); - //int reciever = dot_parse_int(agget(edge,(char*)"reciever")); - - //INFO2("See ",A_dot__uses_file,(is_input?"in":"out")); - file = xbt_dict_get_or_null(files,name); - if (file==NULL) { - file = SD_task_create_comm_e2e(name,NULL,size); - xbt_dict_set(files,name,file,&dot_task_free); - } else { - if (SD_task_get_amount(file)!=size) { - WARN3("Ignoring file %s size redefinition from %.0f to %.0f", - name,SD_task_get_amount(file),size); + /* + * Check if 'root' and 'end' nodes have been explicitly declared. + * If not, create them. + */ + if (!(root = xbt_dict_get_or_null(jobs, "root"))){ + if (seq_or_par == sequential) + root = SD_task_create_comp_seq("root", NULL, 0); + else + root = SD_task_create_comp_par_amdahl("root", NULL, 0, 0); + /* by design the root task is always SCHEDULABLE */ + __SD_task_set_state(root, SD_SCHEDULABLE); + /* Put it at the beginning of the dynar */ + xbt_dynar_insert_at(result, 0, &root); + } + + if (!(end = xbt_dict_get_or_null(jobs, "end"))){ + if (seq_or_par == sequential) + end = SD_task_create_comp_seq("end", NULL, 0); + else + end = SD_task_create_comp_par_amdahl("end", NULL, 0, 0); + /* Should be inserted later in the dynar */ + } + + /* + * Create edges + */ + xbt_dynar_t edges = xbt_dynar_new(sizeof(Agedge_t*), NULL); + for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) { + unsigned cursor; + Agedge_t * edge; + xbt_dynar_reset(edges); + for (edge = agfstout(dag_dot, node); edge; edge = agnxtout(dag_dot, edge)) + xbt_dynar_push_as(edges, Agedge_t *, edge); +#ifdef HAVE_CGRAPH_H + /* Hack: circumvent a bug in libcgraph, where the edges are not always given + * back in creation order. We sort them again, according to their sequence + * id. The problem appears to be solved (i.e.: I did not test it) in + * graphviz' mercurial repository by the following changeset: + * changeset: 8431:d5f1fb7e8103 + * user: Emden Gansner + * date: Tue Oct 11 12:38:58 2011 -0400 + * summary: Make sure edges are stored in node creation order + * It should be fixed in graphviz 2.30 and above. + */ + xbt_dynar_sort(edges, edge_compare); +#endif + xbt_dynar_foreach(edges, cursor, edge) { + SD_task_t src, dst; + char *src_name=agnameof(agtail(edge)); + char *dst_name=agnameof(aghead(edge)); + double size = atof(agget(edge, (char *) "size")); + + src = xbt_dict_get_or_null(jobs, src_name); + dst = xbt_dict_get_or_null(jobs, dst_name); + + if (size > 0) { + char *name = + xbt_malloc((strlen(src_name)+strlen(dst_name)+6)*sizeof(char)); + sprintf(name, "%s->%s", src_name, dst_name); + XBT_DEBUG("See ", name, size); + if (!(task = xbt_dict_get_or_null(jobs, name))) { + if (seq_or_par == sequential) + task = SD_task_create_comm_e2e(name, NULL , size); + else + task = SD_task_create_comm_par_mxn_1d_block(name, NULL , size); +#ifdef HAVE_TRACING + TRACE_sd_dotloader (task, agget (node, (char*)"category")); +#endif + SD_task_dependency_add(NULL, NULL, src, task); + SD_task_dependency_add(NULL, NULL, task, dst); + xbt_dict_set(jobs, name, task, NULL); + 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(NULL,NULL,current_job,file); - if (xbt_dynar_length(file->tasks_before)>1) { - WARN1("File %s created at more than one location...",file->name); + } + xbt_dynar_free(&edges); + + /* all compute and transfer tasks have been created, put the "end" node at + * the end of dynar + */ + XBT_DEBUG("All tasks have been created, put %s at the end of the dynar", + end->name); + xbt_dynar_push(result, &end); + + /* Connect entry tasks to 'root', and exit tasks to 'end'*/ + + xbt_dynar_foreach (result, i, task){ + if (task == root || task == end) + continue; + if (xbt_dynar_is_empty(task->tasks_before)) { + XBT_DEBUG("file '%s' has no source. Add dependency from 'root'", + task->name); + SD_task_dependency_add(NULL, NULL, root, task); + } else if (xbt_dynar_is_empty(task->tasks_after)) { + XBT_DEBUG("file '%s' has no destination. Add dependency to 'end'", + task->name); + SD_task_dependency_add(NULL, NULL, task, end); } -} + } + + agclose(dag_dot); + xbt_dict_free(&jobs); + fclose(in_file); + if (!acyclic_graph_detail(result)) { + XBT_ERROR("The DOT described in %s is not a DAG. It contains a cycle.", + basename((char*)filename)); + xbt_dynar_free(&result); + /* (result == NULL) here */ + } + return result; +}