task_mapping.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "resources.h"
#include "database.h"
#include "ri.h"
#include "ri-util.h"
#include "pipsdbm.h"
#include "misc.h"
#include "properties.h"
#include "task_private.h"
#include "task_parallelization.h"
#include "prettyprint.h"

Include dependency graph for task_mapping.c:

Go to the source code of this file.

Data Structures
struct	ctx_pragma
	ctx_pragma_t: on_cluster on which cluster the pragma may be run (=-1 if run on all cluster) synchro if the communication between cluster are synchro (true) or asynchro(false) if on_cluster=-1 we don't care about the value of synchro d_... More...
struct	ctx_task
	ctx_task_t: pragma information from the pragma task_id id of the task private list of entity, private variables for the task More...

Macros
#define	PRAGMA_DISTRIBUTED   "distributed"

Typedefs
typedef struct ctx_pragma	ctx_pragma_t
	ctx_pragma_t: on_cluster on which cluster the pragma may be run (=-1 if run on all cluster) synchro if the communication between cluster are synchro (true) or asynchro(false) if on_cluster=-1 we don't care about the value of synchro d_... More...
typedef struct ctx_task	ctx_task_t
	ctx_task_t: pragma information from the pragma task_id id of the task private list of entity, private variables for the task More...

Functions
void	print_task (task t)
	Pass: TASK_MAPPING Debug mode: MPI_GENERATION_DEBUG_LEVEL Resource generated: More...
string	task_to_string (task t, bool pretty_print)
static void	print_ctx_pragma (const ctx_pragma_t ctx)
static ctx_pragma_t	init_ctx_pragma ()
	init a ctx_pragma_t by default ctx.on_cluster = -1 run on all cluster ctx.synchro = true com synchro More...
static string	pragma_parameter_unknown_message (string s)
	‍** More...
static bool	pragma_PRAGMA_DISTRIBUTED_p (pragma p)
	Test if the pragma is a PRAGMA_DISTRIBUTED check the first element f the pragma. More...
static ctx_pragma_t	pragma_parse_PRAGMA_DISTRIBUTED (pragma p)
	parse the pragma to generate a ctx_pragma_t need to checked that the pragma sended is a PRAGMA_DISTRIBUTED before More...
static ctx_pragma_t	ctx_pragma_merge (ctx_pragma_t ctx1, ctx_pragma_t ctx2)
	Merge value of 2 ctx_pragma_t, the 2 ctx_pragma_t can't conflict on value. More...
static void	print_ctx_task (const ctx_task_t ctx)
static void	compute_private_entity_list (statement st, ctx_task_t *ctx)
	compute what it must be add in the private entity list essentially internal declaration of the statement More...
static void	assign_statement_task_mapping (statement st, ctx_task_t *ctx)
	assign a task for the statement st More...
static bool	make_task_mapping (__attribute__((unused)) entity module, statement module_statement)
	compute the task mapping requires the module statement as param only parse pragma on fisrt level statement of the module then recurse on all sub-statement to assign the task More...
bool	task_mapping (const char *module_name)
	PIPS pass. More...

Macro Definition Documentation

PRAGMA_DISTRIBUTED

#define PRAGMA_DISTRIBUTED   "distributed"

Definition at line 105 of file task_mapping.c.

Typedef Documentation

ctx_pragma_t

typedef struct ctx_pragma ctx_pragma_t

ctx_pragma_t: on_cluster on which cluster the pragma may be run (=-1 if run on all cluster) synchro if the communication between cluster are synchro (true) or asynchro(false) if on_cluster=-1 we don't care about the value of synchro d_...

if it's a default value or value ask by user

ctx_task_t

typedef struct ctx_task ctx_task_t

ctx_task_t: pragma information from the pragma task_id id of the task private list of entity, private variables for the task

Function Documentation

assign_statement_task_mapping()

static void assign_statement_task_mapping ( statement  st, ctx_task_t *  ctx  )

static

assign a task for the statement st

Parameters

st	statement to be assigned
ctx	context where information about the task are store

Definition at line 348 of file task_mapping.c.

                                                                         {
  task t;
  if (ctx->pragma.on_cluster == -1)
    t = make_task(ctx->task_id, NIL, ctx->pragma.on_cluster, ctx->pragma.synchro);
  else
    t = make_task(ctx->task_id,  gen_copy_seq(ctx->private), ctx->pragma.on_cluster, ctx->pragma.synchro);
  store_or_update_parallel_task_mapping(st, t);
  ifdebug(4) {
    pips_debug(4, "associate statement %p to task %p\n", st, load_parallel_task_mapping(st));
    pips_debug(4, "statement:\n");
    print_statement(st);
    pips_debug(4, "task:\n");
    print_task(load_parallel_task_mapping(st));
  }
}

References gen_copy_seq(), ifdebug, load_parallel_task_mapping(), make_task(), NIL, ctx_pragma::on_cluster, pips_debug, ctx_task::pragma, print_statement(), print_task(), ctx_task::private, store_or_update_parallel_task_mapping(), ctx_pragma::synchro, and ctx_task::task_id.

Referenced by make_task_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_private_entity_list()

static void compute_private_entity_list ( statement  st, ctx_task_t *  ctx  )

static

compute what it must be add in the private entity list essentially internal declaration of the statement

Parameters

st	statement to check
ctx	context where private list is store and update

Definition at line 335 of file task_mapping.c.

                                                                       {
  if (declaration_statement_p(st)) {
    // declarations list of entity declared
    list declarations = statement_declarations(st);
    ctx->private = gen_nconc(ctx->private, gen_copy_seq(declarations));
  }
}

References declaration_statement_p(), gen_copy_seq(), gen_nconc(), ctx_task::private, and statement_declarations.

Referenced by make_task_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

ctx_pragma_merge()

static ctx_pragma_t ctx_pragma_merge ( ctx_pragma_t  ctx1, ctx_pragma_t  ctx2  )

static

Merge value of 2 ctx_pragma_t, the 2 ctx_pragma_t can't conflict on value.

Parameters

ctx1	ctx_pragma_t to merge
ctx2	ctx_pragma_t to merge

Returns

a new ctx_pragma_t with value of ctx1 and ctx2

Definition at line 252 of file task_mapping.c.

                                                                           {
  ctx_pragma_t ctx = init_ctx_pragma();
 
  if (!ctx1.d_on_cluster) {
    ctx.d_on_cluster = false;
    ctx.on_cluster = ctx1.on_cluster;
    if (!(!ctx2.d_on_cluster && ctx1.on_cluster==ctx2.on_cluster)) {
      pips_user_error("conflict between value ask by the user in pragma about on_cluster %d and %d\n", ctx1.on_cluster, ctx2.on_cluster);
    }
  } else if (!ctx2.d_on_cluster) {
    ctx.d_on_cluster = false;
    ctx.on_cluster = ctx2.on_cluster;
  }
 
  if (!ctx1.d_synchro) {
    ctx.d_synchro = false;
    ctx.synchro = ctx1.synchro;
    if (!(!ctx2.d_synchro && ctx1.synchro==ctx2.synchro)) {
      pips_user_error("conflict between value ask by the user in pragma about synchro(wait/nowait) %d and %d\n", ctx1.synchro, ctx2.synchro);
    }
  } else if (!ctx2.d_synchro) {
    ctx.d_synchro = false;
    ctx.synchro = ctx2.synchro;
  }
 
  return ctx;
}

References ctx_pragma::d_on_cluster, ctx_pragma::d_synchro, init_ctx_pragma(), ctx_pragma::on_cluster, pips_user_error, and ctx_pragma::synchro.

Referenced by make_task_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

init_ctx_pragma()

static ctx_pragma_t init_ctx_pragma ( )

static

init a ctx_pragma_t by default ctx.on_cluster = -1 run on all cluster ctx.synchro = true com synchro

Definition at line 134 of file task_mapping.c.

                                      {
  ctx_pragma_t ctx;
  ctx.on_cluster = -1;
  ctx.d_on_cluster = true;
  ctx.synchro = true;
  ctx.d_synchro = true;
  return ctx;
}

References ctx_pragma::d_on_cluster, ctx_pragma::d_synchro, ctx_pragma::on_cluster, and ctx_pragma::synchro.

Referenced by ctx_pragma_merge(), make_task_mapping(), and pragma_parse_PRAGMA_DISTRIBUTED().

Here is the caller graph for this function:

make_task_mapping()

static bool make_task_mapping ( __attribute__((unused)) entity  module, statement  module_statement  )

static

compute the task mapping requires the module statement as param only parse pragma on fisrt level statement of the module then recurse on all sub-statement to assign the task

Parameters

module_statement

module statement to work on

Definition at line 370 of file task_mapping.c.

                                                                                                  {
  if (!statement_sequence_p(module_statement)) {
    pips_internal_error("module_statement have to be the statement of the module/function\n");
    return false;
  }
 
  int task_number = 0;
  // FOREACH statement of the module/function,
  FOREACH(STATEMENT, st, sequence_statements(statement_sequence(module_statement))) {
    //init a a pragma context (execution on all cluster
    ctx_pragma_t ctxp = init_ctx_pragma();
    //check if statement st have a pragma, if true modify pragma context in consequences
    if (statement_with_pragma_p(st)) {
      list lpragmas = statement_pragmas(st);
      FOREACH(PRAGMA, p, lpragmas) {
        if (pragma_PRAGMA_DISTRIBUTED_p(p)) {
          ctx_pragma_t ctxp_temp = pragma_parse_PRAGMA_DISTRIBUTED(p);
          ctxp = ctx_pragma_merge(ctxp, ctxp_temp);
        }
      }
    }
 
    //init the task context
    ctx_task_t ctx;
    ctx.task_id = task_number;
    ctx.pragma = ctxp;
    ctx.private = NIL;
 
    ifdebug(2) {
      pips_debug(2, "work on statement:\n");
      print_statement(st);
      print_ctx_task(ctx);
    }
 
    //make the job
    //first compute_private_entity_list to recursively add private entity
    //second assign_statement_task_mapping to assign a task to each statement
    //can't make the 2 gen_curse into 1 because I want the full private list variable before the assignment of task to statement
    gen_context_recurse(st, &ctx, statement_domain, gen_true2, compute_private_entity_list);
    gen_context_recurse(st, &ctx, statement_domain, gen_true2, assign_statement_task_mapping);
 
    task_number++;
  }
 
  // only present in case of gen_recurse with module_statement to not have seg fault
  // But normally will never be useful
  ctx_task_t ctx;
  ctx.task_id = -1;
  ctx.pragma = init_ctx_pragma();
  ctx.private = NIL;
  //no need
  //compute_private_entity_list(module_statement, &ctx);
  assign_statement_task_mapping(module_statement, &ctx);
 
  return true;
}

References assign_statement_task_mapping(), compute_private_entity_list(), ctx_pragma_merge(), FOREACH, gen_context_recurse, gen_true2(), ifdebug, init_ctx_pragma(), module_statement, NIL, pips_debug, pips_internal_error, PRAGMA, ctx_task::pragma, pragma_parse_PRAGMA_DISTRIBUTED(), pragma_PRAGMA_DISTRIBUTED_p(), print_ctx_task(), print_statement(), ctx_task::private, sequence_statements, STATEMENT, statement_domain, statement_pragmas(), statement_sequence(), statement_sequence_p(), statement_with_pragma_p(), and ctx_task::task_id.

Referenced by task_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_parameter_unknown_message()

static string pragma_parameter_unknown_message ( string  s )

static

‍**

generate a error message about the for the parameter of the pragma to use

Definition at line 158 of file task_mapping.c.

                                                         {
  return concatenate("\nUnknown ", s, " parameter.\n"
                     "Allowed parameters are:\n"
                     "\ton_cluster=n with n a positive number\n"
                     "\tnowait|wait\n", NULL);
}

References concatenate().

Referenced by pragma_parse_PRAGMA_DISTRIBUTED().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_parse_PRAGMA_DISTRIBUTED()

static ctx_pragma_t pragma_parse_PRAGMA_DISTRIBUTED ( pragma  p )

static

parse the pragma to generate a ctx_pragma_t need to checked that the pragma sended is a PRAGMA_DISTRIBUTED before

Parameters

p	pragma to be parsed

Returns

a ctx_pragma_t with the value of the pragma

Definition at line 201 of file task_mapping.c.

                                                              {
  ctx_pragma_t ctx = init_ctx_pragma();
  pips_debug(6, "begin\n parse pragma %p\n", p);
 
  if(pragma_string_p(p)) {
    list lst = strsplit(pragma_string(p), " ");
    //start at the second parameter so CDR(lst)
    FOREACH(STRING, str, CDR(lst)) {
      if(strncasecmp(str, "on_cluster=", 11) == 0) {
        list cluster = strsplit(str, "=");
        if (gen_length(cluster) == 2) {
          string cluster_number = STRING(gen_nth(1, cluster));
          //TODO a better function than atoi may be use, atoi doesn't manage error, strtol too much work is need, remake a custom function?
          ctx.on_cluster = atoi(cluster_number);
          ctx.d_on_cluster = false;
        } else {
          pips_user_warning("unexpected value for parameter on_cluster: %s\n", str);
        }
      }
      else if(strncasecmp(str, "nowait", 7) == 0) {
        ctx.synchro = false;
        ctx.d_synchro = false;
      }
      else if(strncasecmp(str, "wait", 5) == 0) {
        ctx.synchro = true;
        ctx.d_synchro = false;
      }
      else {
        pips_user_warning("%s", pragma_parameter_unknown_message(str));
      }
    }
  }
  //This case normally never appear.
  else if(pragma_expression_p(p)) {
    pips_user_warning("Parse pragma expressions for pragma %s not implemented. This case normally never appear.\n", PRAGMA_DISTRIBUTED);
  }
  else {
    pips_internal_error("We don't know how to handle this kind of pragma !\n");
  }
 
  pips_debug(6, "end\n");
  return ctx;
}

References CDR, ctx_pragma::d_on_cluster, ctx_pragma::d_synchro, FOREACH, gen_length(), gen_nth(), init_ctx_pragma(), ctx_pragma::on_cluster, pips_debug, pips_internal_error, pips_user_warning, PRAGMA_DISTRIBUTED, pragma_expression_p, pragma_parameter_unknown_message(), pragma_string, pragma_string_p, STRING, strsplit(), and ctx_pragma::synchro.

Referenced by make_task_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_PRAGMA_DISTRIBUTED_p()

static bool pragma_PRAGMA_DISTRIBUTED_p ( pragma  p )

static

Test if the pragma is a PRAGMA_DISTRIBUTED check the first element f the pragma.

Parameters

p	pragma to check

Returns

true if p is a PRAGMA_DISTRIBUTED

Definition at line 171 of file task_mapping.c.

                                                  {
  bool r = false;
  if(pragma_string_p(p)) {
    if(strncasecmp(PRAGMA_DISTRIBUTED, pragma_string(p), strlen(PRAGMA_DISTRIBUTED)) == 0) {
      r = true;
    }
  }
  else if(pragma_expression_p(p)) {
    list expr = pragma_expression(p);
    // The list is reversed !
    expression begin = EXPRESSION(CAR(gen_last(expr)));
    if(expression_call_p(begin)) {
      entity called = call_function(expression_call(begin));
      if(strncasecmp(PRAGMA_DISTRIBUTED, entity_local_name(called), strlen(PRAGMA_DISTRIBUTED)) == 0) {
        r = true;
      }
    }
  }
  else {
    pips_internal_error("We don't know how to handle this kind of pragma !\n");
  }
  return r;
}

References call_function, CAR, entity_local_name(), EXPRESSION, expression_call(), expression_call_p(), gen_last(), pips_internal_error, PRAGMA_DISTRIBUTED, pragma_expression, pragma_expression_p, pragma_string, and pragma_string_p.

Referenced by make_task_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

print_ctx_pragma()

static void print_ctx_pragma ( const ctx_pragma_t  ctx )

static

Definition at line 122 of file task_mapping.c.

                                                     {
  fprintf(stderr, "pragma info:\n");
  fprintf(stderr, "on_cluster=%d\n", ctx.on_cluster);
  fprintf(stderr, "synchro=%s\n", ctx.synchro?"true":"false");
}

References fprintf(), ctx_pragma::on_cluster, and ctx_pragma::synchro.

Referenced by print_ctx_task().

Here is the call graph for this function:

Here is the caller graph for this function:

print_ctx_task()

static void print_ctx_task ( const ctx_task_t  ctx )

static

Definition at line 319 of file task_mapping.c.

                                                 {
  print_ctx_pragma(ctx.pragma);
  fprintf(stderr, "task_id=%d\n", ctx.task_id);
  fprintf(stderr, "private list entities:\n");
  FOREACH(ENTITY, e, ctx.private) {
    print_entity_variable(e);
    fprintf(stderr, "\n");
  }
}

References ENTITY, FOREACH, fprintf(), ctx_task::pragma, print_ctx_pragma(), print_entity_variable(), ctx_task::private, and ctx_task::task_id.

Referenced by make_task_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

print_task()

void print_task

(

task

t

)

Pass: TASK_MAPPING Debug mode: MPI_GENERATION_DEBUG_LEVEL Resource generated:

• DBR_TASK

Definition at line 73 of file task_mapping.c.

                        {
  if(task_undefined_p(t))
    fprintf(stderr, "Undefined task\n");
  // For debugging with gdb, dynamic type checking
  else if(task_domain_number(t)!=task_domain)
    (void) fprintf(stderr,"Arg. \"t\"is not a task.\n");
  else {
    fprintf(stderr, "%s", task_to_string(t, false));
  }
}

References fprintf(), task_domain, task_domain_number, task_to_string(), and task_undefined_p.

Referenced by assign_statement_task_mapping(), and print_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

task_mapping()

bool task_mapping

(

const char *

module_name

)

PIPS pass.

Parameters

module_name

odule_name

Definition at line 430 of file task_mapping.c.

                                           {
  entity module;
  statement module_statement;
  bool good_result_p = true;
 
  debug_on("MPI_GENERATION_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  //-- configure environment --//
  set_current_module_entity(module_name_to_entity(module_name));
  module = get_current_module_entity();
 
  set_current_module_statement( (statement)
      db_get_memory_resource(DBR_CODE, module_name, true) );
  module_statement = get_current_module_statement();
 
  pips_assert("Statement should be OK before...",
      statement_consistent_p(module_statement));
 
  init_parallel_task_mapping();
 
  //-- get dependencies --//
  // nothing except code and entity done before.
 
  //TODO look to add parameter in private list?
  //     look module is type functionnal -> list parameter convert to list entitty
 
  //-- Make the job -- //
  make_task_mapping(module, module_statement);
  //  gen_recurse(module_statement, statement_domain, gen_true, print_pragma);
 
  //useless, normally we don't modify the code
  //pips_assert("Statement should be OK after...",
  //    statement_consistent_p(module_statement));
 
  //-- Save modified code to database --//
  //  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
  DB_PUT_MEMORY_RESOURCE(DBR_TASK, module_name, get_parallel_task_mapping());
  //  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name,
  //       compute_callees(module_statement));
 
  reset_current_module_statement();
  reset_current_module_entity();
  reset_parallel_task_mapping();
 
  pips_debug(1, "end\n");
  debug_off();
 
  return (good_result_p);
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_entity(), get_current_module_statement(), get_parallel_task_mapping(), init_parallel_task_mapping(), make_task_mapping(), module, module_name(), module_name_to_entity(), module_statement, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_parallel_task_mapping(), set_current_module_entity(), set_current_module_statement(), and statement_consistent_p().

Here is the call graph for this function:

task_to_string()

string task_to_string	(	task	t,
		bool	pretty_print
	)

Parameters

pretty_print

retty_print

Definition at line 84 of file task_mapping.c.

                                                 {
  char tid[10+4];
  string tprivate = "";
  char tcluster[18+4];
  char tsync[23+5];
  snprintf(tid, 10+4, "task_id=%"_intFMT"\n", task_id(t));
  snprintf(tcluster, 18+4, "task_on_cluster=%"_intFMT"\n", task_on_cluster(t));
  snprintf(tsync, 23+5, "task_synchronization=%s\n", task_synchronization(t)?"true":"false");
  tprivate = "task_private_data={";
  FOREACH(ENTITY, ep, task_private_data(t)) {
    pips_debug(8, "%s", entity_name(ep));
    tprivate = concatenate(tprivate, pretty_print?entity_user_name(ep):entity_name(ep), "; ", (char *) NULL);
  }
  tprivate = strdup(concatenate(tprivate, "}\n", (char *) NULL));
  return concatenate(tid, tprivate, tcluster, tsync, (char *) NULL);
}

References _intFMT, concatenate(), ENTITY, entity_name, entity_user_name(), FOREACH, pips_debug, strdup(), task_id, task_on_cluster, task_private_data, and task_synchronization.

Referenced by prepare_context(), and print_task().

Here is the call graph for this function:

Here is the caller graph for this function: