mpi_conversion.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 "control.h"
#include "misc.h"
#include "syntax.h"
#include "c_syntax.h"
#include "properties.h"
#include "task_parallelization.h"
#include "prettyprint.h"

Include dependency graph for mpi_conversion.c:

Go to the source code of this file.

Data Structures
struct	ctx_mpi
	return the type for MPI datatype (to make custom datatype for example): MPI_Datatype More...
struct	ctx_conv

Typedefs
typedef struct ctx_mpi	ctx_mpi_t
	return the type for MPI datatype (to make custom datatype for example): MPI_Datatype More...
typedef struct ctx_conv	ctx_conv_t

Enumerations
enum	mpi_communication_mode { mpi_communication_default_mode , mpi_communication_synchronous_mode , mpi_communication_ready_mode , mpi_communication_buffered_mode }

Functions
static string	mpi_conversion_declaration_commenter (__attribute__((unused)) entity e)
	Pass: MPI_CONVERSION Debug mode: MPI_GENERATION_DEBUG_LEVEL Properties used: More...
static statement	mpic_make_mpi_comm_size (entity communicator, entity size, entity result)
	Functions to generate standard MPI function statement Can maybe also make function to return MPI function like instruction instead of statement to be more flexible? Only C version are made, for Fortran version, have to add an error manager variable (instead return result in C than represent possible error, add it in call function, cf MPI doc) All these functions can be general and move into a MPI manager? In that case only unstatic function that return statement or type. More...
static statement	mpic_make_mpi_comm_rank (entity communicator, entity rank, entity result)
	generate statement: MPI_Comm_rank(communicator, &rank); or result = MPI_Comm_rank(communicator, &rank); More...
static statement	mpic_make_mpi_init (entity result, entity argc, entity argv)
	argc and argv must be defined generate statement: MPI_Init(&argc, &argv); or result = MPI_Init(&argc, &argv); More...
static statement	mpic_make_mpi_finalize (entity result)
	generate statement: MPI_Finalize(); or result = MPI_Finalize(); More...
static list	mpic_make_args_mpi_send_or_receiv (expression buffer, int size, entity mpitype, int ds, int tag, entity communicator, entity status, entity request)
	tatic statement mpifortran_make_mpi_finalize(entity result) { list args = CONS(EXPRESSION, make_entity_expression(result, NIL), NIL); args = gen_nreverse(args); statement mpi_st = make_call_statement(MPI_FINALIZE_FUNCTION_NAME, args, entity_undefined, string_undefined); return mpi_st; } More...
static call	mpic_make_generic_mpi_send_call (expression buffer, int size, entity mpitype, int dest, int tag, entity communicator, entity request, enum mpi_communication_mode mode)
static call	mpic_make_generic_mpi_receive_call (expression buffer, int size, entity mpitype, int dest, int tag, entity communicator, entity status, entity request)
static statement	mpic_make_mpi_send (expression buffer, int size, entity mpitype, int dest, int tag, entity communicator, entity result)
	generate statement: {result =} MPI_Send(&buffer, size, mpitype, dest, tag, communicator); More...
static statement	mpic_make_mpi_isend (expression buffer, int size, entity mpitype, int dest, int tag, entity communicator, entity request, entity result)
	generate statement: {result =} MPI_Isend(&buffer, size, mpitype, dest, tag, communicator, &request); More...
static statement	mpic_make_mpi_recv (expression buffer, int size, entity mpitype, int source, int tag, entity communicator, entity status, entity result)
	TODO do the same for MPI_Rsend/Irsend/Bsend/Ibsend/Ssend/Issend. More...
static statement	mpic_make_mpi_irecv (expression buffer, int size, entity mpitype, int source, int tag, entity communicator, entity request, entity result)
	generate statement: {result =} MPI_Irecv(&buffer, size, mpitype, source, tag, communicator, &request); More...
static type	mpi_type_mpi_comm ()
	return the type for MPI communicator: MPI_Comm More...
static type	mpi_type_mpi_status ()
	return the type for MPI status: MPI_Status More...
static type	mpi_type_mpi_request ()
	return the type for MPI request: MPI_Request More...
static ctx_mpi_t	mpi_make_ctx (entity module)
static void	mpi_free_ctx (__attribute__((__unused__)) ctx_mpi_t *ctx)
static statement	mpi_comm_size_ctx (const ctx_mpi_t ctx)
static statement	mpi_comm_rank_ctx (const ctx_mpi_t ctx)
static statement	mpi_init_ctx (const ctx_mpi_t ctx)
static statement	mpi_finalize_ctx (const ctx_mpi_t ctx)
static statement	mpi_send_ctx (const ctx_mpi_t ctx, expression buffer, int size, int dest, int tag, bool blocking)
static statement	mpi_recv_ctx (const ctx_mpi_t ctx, expression buffer, int size, int source, int tag, bool blocking)
	TODO do the same for Ssend, Rsend, Bsend. More...
static ctx_conv_t	conv_make_ctx (entity module, int nbr_cluster)
static void	conv_free_ctx (ctx_conv_t *ctx)
static void	ctx_init (ctx_conv_t *ctx)
static void	ctx_set_return_statement (ctx_conv_t *ctx, statement rs)
static statement	ctx_get_return_statement (const ctx_conv_t ctx)
static void	ctx_set_statement_work_on (ctx_conv_t *ctx, statement st)
static statement	ctx_get_statement_work_on (const ctx_conv_t ctx)
static void	ctx_set_send_statement (ctx_conv_t *ctx, statement send)
static statement	ctx_get_send_statement (ctx_conv_t *ctx)
static void	ctx_set_receive_statement (ctx_conv_t *ctx, statement receive, int for_cluster)
static statement	ctx_get_receive_statement (const ctx_conv_t ctx, int for_cluster)
static bool	ctx_is_blocking (const ctx_conv_t ctx)
static int	ctx_get_tag (const ctx_conv_t ctx, int sender, int receiver)
static void	ctx_inc_tag (ctx_conv_t *ctx, int sender, int receiver)
static statement	ctx_generate_new_statement_cluster_dependant (const ctx_conv_t ctx)
static void	initilization (statement module_statement, const ctx_conv_t ctx)
	put initialize MPI functions at the beginning of the module_stateent (function): // Generated by Pass MPI_CONVERSION MPI_Status status0; // Generated by Pass MPI_CONVERSION MPI_Request request0; // Generated by Pass MPI_CONVERSION int size0, rank0; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size0); MPI_Comm_rank(MPI_COMM_WORLD, &rank0); More...
static void	finalization (statement module_statement, const ctx_conv_t ctx)
	put finalize MPI functions at the end of the module_stateent (function), before the return: MPI_Finalize(); More...
static bool	is_distributed_comments (string comments)
static bool	is_distributed_send_comments (string comments)
static bool	is_distributed_receive_comments (string comments)
static int	find_sender_cluster (ctx_conv_t *ctx, __attribute__((__unused__)) statement stat)
static int	find_receiver_cluster (__attribute__((__unused__)) ctx_conv_t *ctx, statement stat)
static statement	generate_send_from_statement (ctx_conv_t *ctx, statement stat)
static statement	generate_receive_from_statement (ctx_conv_t *ctx, statement stat)
static void	replace_sender_entity_by_receiver_entity_in_reference (reference ref, int *receiv_cluster)
static bool	sequence_working_false (sequence seq, ctx_conv_t *ctx)
	This function update the receive statements for a sequential statement NB : This function can be put in search_copy_communication; in this case search_copy_communication can return true and false And have to treat the declaration here instead of in make_send_receive_conversion. More...
static bool	test_working_false (test t, ctx_conv_t *ctx)
	This function update the receive statements for a test statement NB : This function can be put in search_copy_communication; in this case search_copy_communication can return true and false. More...
static bool	search_copy_communication (statement stat, ctx_conv_t *ctx)
	use as filter for gen_context_recurse check if the statement stat will be communication if so, generate the MPI_Send and MPI_Receive corresponding. More...
static void	make_send_receive_conversion (statement stat, ctx_conv_t *ctx)
	Update statement that we work on by replace communication assignment by real MPI_send function and compute the corresponding MPI_receiv that must be done. More...
static statement	make_mpi_conversion (entity module, statement module_statement)
bool	mpi_conversion (const char *module_name)
	PIPS pass. More...

Typedef Documentation

ctx_conv_t

typedef struct ctx_conv ctx_conv_t

ctx_mpi_t

typedef struct ctx_mpi ctx_mpi_t

return the type for MPI datatype (to make custom datatype for example): MPI_Datatype

tatic type mpi_type_MPI_Datatype() { entity req = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, MPI_DATATYPE); if(storage_undefined_p(entity_storage(req))) { entity_storage(req) = make_storage_rom(); put_new_typedef(MPI_DATATYPE); } type req_t =MakeTypeVariable(make_basic_typedef(req), NIL); if(type_undefined_p(entity_type(req))) { entity_type(req) = ImplicitType(req); } return req_t; } Wrapper to call generic MPI function maker

Enumeration Type Documentation

mpi_communication_mode

enum mpi_communication_mode

Enumerator
mpi_communication_default_mode
mpi_communication_synchronous_mode
mpi_communication_ready_mode
mpi_communication_buffered_mode

Definition at line 70 of file mpi_conversion.c.

                            {
  mpi_communication_default_mode,
  mpi_communication_synchronous_mode,
  mpi_communication_ready_mode,
  mpi_communication_buffered_mode
};

Function Documentation

conv_free_ctx()

static void conv_free_ctx ( ctx_conv_t *  ctx )

static

Definition at line 679 of file mpi_conversion.c.

                                            {
//  pips_assert("stack of task not empty", stack_size(ctx->stack_task) == 0);
////  pips_assert("current_task have to be undefined", ctx->current_task == task_undefined);
  mpi_free_ctx(&ctx->ctx_mpi);
 
//  if (ctx->current_cluster >= 0) {
//    statement st = (statement)hash_get(ctx->hash_statement_to_add, &(ctx->current_cluster);
//    free_statement(st);
//  }
  for (int i = 0; i < ctx->nbr_cluster; ++i) {
    free(ctx->tag[i]);
  }
  free(ctx->tag);
 
//  free(ctx->statement_to_add);
  //free(ctx->statement_body);
  free(ctx->statement_send_receive);
  return;
}

References ctx_conv::ctx_mpi, free(), mpi_free_ctx(), ctx_conv::nbr_cluster, ctx_conv::statement_send_receive, and ctx_conv::tag.

Referenced by make_mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

conv_make_ctx()

static ctx_conv_t conv_make_ctx ( entity  module, int  nbr_cluster  )

static

Definition at line 646 of file mpi_conversion.c.

                                                                {
  pips_assert("number of cluster can't be equal to 0", nbr_cluster != 0);
  ctx_conv_t ctx;
 
  ctx.ctx_mpi = mpi_make_ctx(module);
 
//  ctx.hash_statement_to_add = hash_table_make(hash_int, nbr_cluster);
//  ctx.hash_statement_receive = hash_table_make(hash_int, nbr_cluster);
//  ctx.statement_to_add = malloc(sizeof(*(ctx.statement_to_add)) * nbr_cluster);
  //ctx.statement_body = malloc(sizeof(*(ctx.statement_body)) * nbr_cluster);
  ctx.statement_send_receive = malloc(sizeof(*(ctx.statement_send_receive)) * nbr_cluster);
  for (int i = 0; i < nbr_cluster; ++i) {
    ctx.statement_send_receive[i] = statement_undefined;
  }
  ctx.statement_work_on = statement_undefined;
 
  ctx.nbr_cluster = nbr_cluster;
  ctx.current_cluster = -2;
  ctx.current_task = task_undefined;
  //ctx.last_cluster = -2;
 
  ctx.tag = malloc(sizeof(*(ctx.tag)) * nbr_cluster);
  for (int i = 0; i < nbr_cluster; ++i) {
    ctx.tag[i] = malloc(sizeof(**(ctx.tag)) * nbr_cluster);
    for (int j = 0; j < nbr_cluster; ++j) {
      ctx.tag[i][j] = 0;
    }
  }
 
  ctx.return_statement = statement_undefined;
 
  return ctx;
}

References ctx_conv::ctx_mpi, ctx_conv::current_cluster, ctx_conv::current_task, malloc(), module, mpi_make_ctx(), ctx_conv::nbr_cluster, pips_assert, ctx_conv::return_statement, ctx_conv::statement_send_receive, statement_undefined, ctx_conv::statement_work_on, ctx_conv::tag, and task_undefined.

Referenced by make_mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

ctx_generate_new_statement_cluster_dependant()

static statement ctx_generate_new_statement_cluster_dependant ( const ctx_conv_t  ctx )

static

Returns

if (rank==p) { [...] MPI_Send(); } if (rank==0) { [...] MPI_Recv(); } [...] if (rank==n) { [...] MPI_Recv(); }

Definition at line 874 of file mpi_conversion.c.

                                                                                    {
  int current_cluster = ctx.current_cluster;
  statement st = make_empty_block_statement();
//  hash_table hsta = ctx.hash_statement_to_add;
 
  {
//  statement current = (statement) hash_get(hsta, (void *)(current_cluster+1));
//  statement current = ctx.statement_to_add[current_cluster];
//  insert_statement(st, current, false);
    statement current = ctx.statement_work_on;
    expression cond = MakeBinaryCall(entity_intrinsic(EQUAL_OPERATOR_NAME), entity_to_expression(ctx.ctx_mpi.rank), int_to_expression(current_cluster));
    statement add = make_test_statement(cond, current, make_empty_block_statement());
    insert_statement(st, add, false);
  }
 
  int i=0;
  for (i=0; i<ctx.nbr_cluster; i++) {
    if (i != current_cluster) {
//      statement add = (statement) hash_get(hsta, (void *)i);
//      statement add = ctx.statement_to_add[i];
      statement receiv = ctx.statement_send_receive[i];
      if (!statement_undefined_p(receiv)) {
        expression cond = MakeBinaryCall(entity_intrinsic(EQUAL_OPERATOR_NAME), entity_to_expression(ctx.ctx_mpi.rank), int_to_expression(i));
        statement add = make_test_statement(cond, receiv, make_empty_block_statement());
        insert_statement(st, add, false);
        ctx.statement_send_receive[i] = statement_undefined;
      }
    }
  }
 
  return st;
}

References ctx_conv::ctx_mpi, current, ctx_conv::current_cluster, entity_intrinsic(), entity_to_expression(), EQUAL_OPERATOR_NAME, insert_statement(), int_to_expression(), make_empty_block_statement(), make_test_statement(), MakeBinaryCall(), ctx_conv::nbr_cluster, ctx_mpi::rank, ctx_conv::statement_send_receive, statement_undefined, statement_undefined_p, and ctx_conv::statement_work_on.

Referenced by make_mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

ctx_get_receive_statement()

static statement ctx_get_receive_statement ( const ctx_conv_t  ctx, int  for_cluster  )

static

Definition at line 820 of file mpi_conversion.c.

                                                                                  {
  pips_assert("for_cluster and ctx.current_cluster must be different\n", ctx.current_cluster!=for_cluster);
  statement receive = ctx.statement_send_receive[for_cluster];
  return receive;
}

References ctx_conv::current_cluster, pips_assert, and ctx_conv::statement_send_receive.

Referenced by make_send_receive_conversion(), sequence_working_false(), and test_working_false().

Here is the caller graph for this function:

ctx_get_return_statement()

static statement ctx_get_return_statement ( const ctx_conv_t  ctx )

static

Definition at line 738 of file mpi_conversion.c.

                                                                {
  return ctx.return_statement;
}

References ctx_conv::return_statement.

Referenced by finalization().

Here is the caller graph for this function:

ctx_get_send_statement()

static statement ctx_get_send_statement ( ctx_conv_t *  ctx )

static

Definition at line 809 of file mpi_conversion.c.

                                                          {
  pips_assert("ctx->send_statement mustn't be statement_undefined\n", !statement_undefined_p(ctx->statement_send_receive[ctx->current_cluster]));
  statement send = ctx->statement_send_receive[ctx->current_cluster];
  print_statement(send);
  ctx->statement_send_receive[ctx->current_cluster] = statement_undefined;
  return send;
}

References ctx_conv::current_cluster, pips_assert, print_statement(), ctx_conv::statement_send_receive, statement_undefined, and statement_undefined_p.

Referenced by make_send_receive_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

ctx_get_statement_work_on()

static statement ctx_get_statement_work_on ( const ctx_conv_t  ctx )

static

Definition at line 766 of file mpi_conversion.c.

                                                                 {
  //int current_cluster = ctx.current_cluster;
  //statement st = ctx.statement_body[current_cluster];
  statement st = ctx.statement_work_on;
  return st;
}

References ctx_conv::statement_work_on.

Referenced by make_mpi_conversion(), and make_send_receive_conversion().

Here is the caller graph for this function:

ctx_get_tag()

static int ctx_get_tag ( const ctx_conv_t  ctx, int  sender, int  receiver  )

static

Definition at line 847 of file mpi_conversion.c.

                                                                       {
  pips_assert("sender_cluster<nbr_cluster\n", sender<ctx.nbr_cluster);
  pips_assert("receiver_cluster<nbr_cluster\n", receiver<ctx.nbr_cluster);
  return ctx.tag[sender][receiver];
}

References ctx_conv::nbr_cluster, pips_assert, and ctx_conv::tag.

Referenced by generate_receive_from_statement(), and generate_send_from_statement().

Here is the caller graph for this function:

ctx_inc_tag()

static void ctx_inc_tag ( ctx_conv_t *  ctx, int  sender, int  receiver  )

static

Definition at line 852 of file mpi_conversion.c.

                                                                    {
  pips_assert("sender_cluster<nbr_cluster\n", sender<ctx->nbr_cluster);
  pips_assert("receiver_cluster<nbr_cluster\n", receiver<ctx->nbr_cluster);
  ctx->tag[sender][receiver]++;
}

References pips_assert, and ctx_conv::tag.

Referenced by search_copy_communication().

Here is the caller graph for this function:

ctx_init()

static void ctx_init ( ctx_conv_t *  ctx )

static

Definition at line 701 of file mpi_conversion.c.

                                       {
  int i = 0;
  for (i=0; i<ctx->nbr_cluster; i++) {
    //   statement body = make_empty_block_statement();
    //  expression cond = MakeBinaryCall(entity_intrinsic(EQUAL_OPERATOR_NAME), entity_to_expression(ctx->ctx_mpi.rank), int_to_expression(i));
    //  statement stadd = make_test_statement(cond, body, make_empty_block_statement());
 
//    hash_put_or_update(ctx->hash_statement_receive, (void *)i, receive);
//    hash_put_or_update(ctx->hash_statement_to_add,  (void *)i, stadd);
    ctx->statement_send_receive[i] = statement_undefined;
    //ctx->statement_body[i] = body;
//    ctx->statement_to_add[i] = stadd;
  }
}

References ctx_conv::nbr_cluster, ctx_conv::statement_send_receive, and statement_undefined.

Referenced by ctx_set_statement_work_on().

Here is the caller graph for this function:

ctx_is_blocking()

static bool ctx_is_blocking ( const ctx_conv_t  ctx )

static

Definition at line 842 of file mpi_conversion.c.

                                                  {
  task ta = ctx.current_task;
  return (bool) task_synchronization(ta);
}

References ctx_conv::current_task, and task_synchronization.

Referenced by generate_receive_from_statement(), and generate_send_from_statement().

Here is the caller graph for this function:

ctx_set_receive_statement()

static void ctx_set_receive_statement ( ctx_conv_t *  ctx, statement  receive, int  for_cluster  )

static

Definition at line 816 of file mpi_conversion.c.

                                                                                            {
  pips_assert("for_cluster and ctx.current_cluster must be different\n", ctx->current_cluster!=for_cluster);
  ctx->statement_send_receive[for_cluster] = receive;
}

References ctx_conv::current_cluster, pips_assert, and ctx_conv::statement_send_receive.

Referenced by make_send_receive_conversion(), search_copy_communication(), sequence_working_false(), and test_working_false().

Here is the caller graph for this function:

ctx_set_return_statement()

static void ctx_set_return_statement ( ctx_conv_t *  ctx, statement  rs  )

static

Definition at line 732 of file mpi_conversion.c.

                                                                     {
  if (!statement_undefined_p(ctx->return_statement)) {
    pips_user_error("Can only have one return statement :(\n");
  }
  ctx->return_statement = copy_statement(rs);
}

References copy_statement(), pips_user_error, ctx_conv::return_statement, and statement_undefined_p.

Referenced by make_mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

ctx_set_send_statement()

static void ctx_set_send_statement ( ctx_conv_t *  ctx, statement  send  )

static

Definition at line 805 of file mpi_conversion.c.

                                                                     {
  pips_assert("ctx->send_statement must be statement_undefined\n", statement_undefined_p(ctx->statement_send_receive[ctx->current_cluster]));
  ctx->statement_send_receive[ctx->current_cluster] = send;
}

References ctx_conv::current_cluster, pips_assert, ctx_conv::statement_send_receive, and statement_undefined_p.

Referenced by search_copy_communication().

Here is the caller graph for this function:

ctx_set_statement_work_on()

static void ctx_set_statement_work_on ( ctx_conv_t *  ctx, statement  st  )

static

Definition at line 742 of file mpi_conversion.c.

                                                                      {
  //each time we work on a new task, we reinitialize the context
  //especially the statements to generate
  ctx_init(ctx);
 
  task ta = load_parallel_task_mapping(st);
  ctx->current_task = ta;
  int cluster = task_on_cluster(ta);
  ctx->current_cluster = cluster;
 
  statement stat = copy_statement(st);
  free_extensions(statement_extensions(stat));
  statement_extensions(stat) = empty_extensions();
 
//  statement testst = (statement) hash_get(ctx->hash_statement_to_add, (void *)(cluster));
//  statement testst = ctx->statement_to_add[cluster];
//  test te = statement_test(testst);
//  free_statement(test_true(te));
//  test_true(te) = stat;
 
//  hash_put_or_update(ctx->hash_statement_receive, (void *)(cluster), st);
  //ctx->statement_body[cluster] = stat;
  ctx->statement_work_on = stat;
}

References copy_statement(), ctx_init(), ctx_conv::current_cluster, ctx_conv::current_task, empty_extensions(), free_extensions(), load_parallel_task_mapping(), statement_extensions, ctx_conv::statement_work_on, and task_on_cluster.

Referenced by make_mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

finalization()

static void finalization ( statement  module_statement, const ctx_conv_t  ctx  )

static

put finalize MPI functions at the end of the module_stateent (function), before the return: MPI_Finalize();

Definition at line 940 of file mpi_conversion.c.

                                                                           {
  insert_statement(module_statement, mpi_finalize_ctx(ctx.ctx_mpi), false);
  statement rs = ctx_get_return_statement(ctx);
  if (!statement_undefined_p(rs))
    insert_statement(module_statement, rs, false);
}

References ctx_get_return_statement(), ctx_conv::ctx_mpi, insert_statement(), module_statement, mpi_finalize_ctx(), and statement_undefined_p.

Referenced by make_mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

find_receiver_cluster()

static int find_receiver_cluster ( __attribute__((__unused__)) ctx_conv_t *  ctx, statement  stat  )

static

Definition at line 992 of file mpi_conversion.c.

                                                                                                {
  pips_assert("statement stat is copy receive statement",
      is_distributed_receive_comments(statement_comments(stat)) && assignment_statement_p(stat));
 
  call c = statement_call(stat);
  list args = call_arguments(c);
  expression lhs = EXPRESSION(CAR(args));
 
  entity lhse = expression_to_entity(lhs);
  string lhsname = entity_name(lhse);
  list l = strsplit(lhsname, "_");
  return atoi(STRING(CAR(gen_nreverse(l))));
}

References assignment_statement_p(), call_arguments, CAR, entity_name, EXPRESSION, expression_to_entity(), gen_nreverse(), is_distributed_receive_comments(), pips_assert, statement_call(), statement_comments, STRING, and strsplit().

Referenced by generate_receive_from_statement(), generate_send_from_statement(), and search_copy_communication().

Here is the call graph for this function:

Here is the caller graph for this function:

find_sender_cluster()

static int find_sender_cluster ( ctx_conv_t *  ctx, __attribute__((__unused__)) statement  stat  )

static

Definition at line 977 of file mpi_conversion.c.

                                                                                              {
//  pips_assert("statement stat is copy receive statement",
//      is_distributed_send_comments(statement_comments(stat)) && assignment_statement_p(stat));
//
//  call c = statement_call(stat);
//  list args = call_arguments(c);
//  expression rhs = EXPRESSION(CAR(CDR(args)));
//
//  entity rhse = expression_to_entity(rhs);
//  string rhsname = entity_name(rhse);
//  list l = strsplit(rhsname, "_");
//  return atoi(STRING(CAR(gen_nreverse(l))));
  return ctx->current_cluster;
}

References ctx_conv::current_cluster.

Referenced by generate_receive_from_statement(), generate_send_from_statement(), and search_copy_communication().

Here is the caller graph for this function:

generate_receive_from_statement()

static statement generate_receive_from_statement ( ctx_conv_t *  ctx, statement  stat  )

static

Definition at line 1030 of file mpi_conversion.c.

                                                                                   {
  statement st = statement_undefined;
 
  pips_assert("statement stat is copy receive statement",
      is_distributed_receive_comments(statement_comments(stat)) && assignment_statement_p(stat));
 
  expression buffer = expression_undefined;
  int sender = find_sender_cluster(ctx, stat);
  int receiver = find_receiver_cluster(ctx, stat);
  int tag = ctx_get_tag(*ctx, sender, receiver);
  bool blocking = ctx_is_blocking(*ctx);
 
  call c = statement_call(stat);
  list args = call_arguments(c);
  expression lhs = EXPRESSION(CAR(args));
  //  expression rhs = EXPRESSION(CAR(CDR(args)));
 
  buffer = copy_expression(lhs);
 
  st = mpi_recv_ctx(ctx->ctx_mpi, buffer, 1, sender, tag, blocking);
 
  return st;
}

References assignment_statement_p(), buffer, call_arguments, CAR, copy_expression(), ctx_get_tag(), ctx_is_blocking(), ctx_conv::ctx_mpi, EXPRESSION, expression_undefined, find_receiver_cluster(), find_sender_cluster(), is_distributed_receive_comments(), mpi_recv_ctx(), pips_assert, statement_call(), statement_comments, and statement_undefined.

Referenced by search_copy_communication().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_send_from_statement()

static statement generate_send_from_statement ( ctx_conv_t *  ctx, statement  stat  )

static

Definition at line 1006 of file mpi_conversion.c.

                                                                                {
  statement st = statement_undefined;
 
  pips_assert("statement stat is copy send statement",
      is_distributed_send_comments(statement_comments(stat)) && assignment_statement_p(stat));
 
  expression buffer = expression_undefined;
  int sender = find_sender_cluster(ctx, stat);
  int receiver = find_receiver_cluster(ctx, stat);
  int tag = ctx_get_tag(*ctx, sender, receiver);
  bool blocking = ctx_is_blocking(*ctx);
 
  call c = statement_call(stat);
  list args = call_arguments(c);
  //  expression lhs = EXPRESSION(CAR(args));
   expression rhs = EXPRESSION(CAR(CDR(args)));
 
  buffer = copy_expression(rhs);
 
  st = mpi_send_ctx(ctx->ctx_mpi, buffer, 1, receiver, tag, blocking);
 
  return st;
}

References assignment_statement_p(), buffer, call_arguments, CAR, CDR, copy_expression(), ctx_get_tag(), ctx_is_blocking(), ctx_conv::ctx_mpi, EXPRESSION, expression_undefined, find_receiver_cluster(), find_sender_cluster(), is_distributed_send_comments(), mpi_send_ctx(), pips_assert, statement_call(), statement_comments, and statement_undefined.

Referenced by search_copy_communication().

Here is the call graph for this function:

Here is the caller graph for this function:

initilization()

static void initilization ( statement  module_statement, const ctx_conv_t  ctx  )

static

put initialize MPI functions at the beginning of the module_stateent (function): // Generated by Pass MPI_CONVERSION MPI_Status status0; // Generated by Pass MPI_CONVERSION MPI_Request request0; // Generated by Pass MPI_CONVERSION int size0, rank0; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size0); MPI_Comm_rank(MPI_COMM_WORLD, &rank0);

Definition at line 923 of file mpi_conversion.c.

                                                                            {
  insert_statement(module_statement, mpi_comm_rank_ctx(ctx.ctx_mpi), true);
  insert_statement(module_statement, mpi_comm_size_ctx(ctx.ctx_mpi), true);
  insert_statement(module_statement, mpi_init_ctx(ctx.ctx_mpi), true);
 
  push_generated_variable_commenter(mpi_conversion_declaration_commenter);
  add_declaration_statement_at_beginning(module_statement, ctx.ctx_mpi.rank);
  add_declaration_statement_at_beginning(module_statement, ctx.ctx_mpi.size);
  add_declaration_statement_at_beginning(module_statement, ctx.ctx_mpi.mpi_request);
  add_declaration_statement_at_beginning(module_statement, ctx.ctx_mpi.mpi_status);
  pop_generated_variable_commenter();
}

References add_declaration_statement_at_beginning(), ctx_conv::ctx_mpi, insert_statement(), module_statement, mpi_comm_rank_ctx(), mpi_comm_size_ctx(), mpi_conversion_declaration_commenter(), mpi_init_ctx(), ctx_mpi::mpi_request, ctx_mpi::mpi_status, pop_generated_variable_commenter(), push_generated_variable_commenter(), ctx_mpi::rank, and ctx_mpi::size.

Referenced by make_mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

is_distributed_comments()

static bool is_distributed_comments ( string  comments )

static

Definition at line 948 of file mpi_conversion.c.

                                                     {
  if (empty_comments_p(comments))
    return false;
 
  string dist = "distributed";
 
  return strstr(comments, dist) != NULL;
}

References empty_comments_p().

Referenced by make_send_receive_conversion(), and search_copy_communication().

Here is the call graph for this function:

Here is the caller graph for this function:

is_distributed_receive_comments()

static bool is_distributed_receive_comments ( string  comments )

static

Definition at line 967 of file mpi_conversion.c.

                                                             {
  if (empty_comments_p(comments))
    return false;
 
  string dist = "distributed";
  string receive = "receive";
 
  return strstr(comments, dist) != NULL && strstr(comments, receive) != NULL;
}

References empty_comments_p().

Referenced by find_receiver_cluster(), and generate_receive_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

is_distributed_send_comments()

static bool is_distributed_send_comments ( string  comments )

static

Definition at line 957 of file mpi_conversion.c.

                                                          {
  if (empty_comments_p(comments))
    return false;
 
  string dist = "distributed";
  string send = "send";
 
  return strstr(comments, dist) != NULL && strstr(comments, send) != NULL;
}

References empty_comments_p().

Referenced by generate_send_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

make_mpi_conversion()

static statement make_mpi_conversion ( entity  module, statement  module_statement  )

static

en_null

en_null

Definition at line 1901 of file mpi_conversion.c.

                                                                                {
  ifdebug(2) {
    pips_debug(2, "begin\n");
    pips_debug(2, "statement with : \n");
    print_statement(module_statement);
  }
  statement new_module_statement = make_empty_block_statement();
 
 
  if (statement_sequence_p(module_statement)) {
    int nbr_copy = get_int_property(MPI_GENERATION_NBR_CLUSTER);
    ctx_conv_t ctx;
    ctx = conv_make_ctx(module, nbr_copy);
    sequence seq = statement_sequence(module_statement);
    list stats = sequence_statements(seq);
 
    //0. init the environement
    initilization(new_module_statement , ctx);
 
    //1. Work task by task
    //   Modify the control flow graph
    //   To add if (rank==x) ...
    FOREACH(STATEMENT, s, stats) {
      if (declaration_statement_p(s)) {
        statement new_decl = copy_statement(s);
        insert_statement_no_matter_what(new_module_statement, new_decl, false);
        //No need?
        //statement_declarations(new_module_statement) = gen_append(statement_declarations(new_module_statement), statement_declarations(new_decl));
      }
      else if (return_statement_p(s)) {
        ctx_set_return_statement(&ctx, s);
      }
      else if (statement_sequence_p(s)) {
        ctx_set_statement_work_on(&ctx, s);
 
 
        gen_context_multi_recurse(ctx_get_statement_work_on(ctx), &ctx
//        gen_context_recurse(ctx_get_statement_work_on(ctx), &ctx
            , statement_domain, search_copy_communication, make_send_receive_conversion
            , sequence_domain, sequence_working_false, gen_core /*gen_null*/
            , test_domain, test_working_false, gen_core /*gen_null*/
//            , loop_domain, gen_true, gen_true
//            , whileloop_domain, gen_true, gen_true
//            , forloop_domain, gen_true, gen_true
//            //, call_domain, gen_true, gen_true             // to detect copy for communication statement done in statement_domaine case
//            //, multitest_domain, gen_true, gen_true        // don't exist in PIPS yet
//            //, unstructured_domain, gen_true, gen_true     // never happens? bug case?
//            //, expression_domain, gen_true, gen_true
            , NULL
            );
 
//        gen_context_recurse(ctx_get_statement_work_on(ctx), &ctx, statement_domain, gen_true, make_send_conversion);
//        gen_context_recurse(ctx_get_statement_work_on(ctx), &ctx, statement_domain, gen_true, make_receive_conversion);
 
        insert_statement(new_module_statement , ctx_generate_new_statement_cluster_dependant(ctx), false);
//        free_statement(s);
//        s = status_undefined;
//        print_statement(new_module_statement );
      }
      else {
        print_statement(s);
        pips_internal_error("This case never happen?\n");
      }
    }
 
    //2. close the environement
    finalization(new_module_statement , ctx);
 
    conv_free_ctx(&ctx);
    free_statement(module_statement);
  } else {
    free_statement(new_module_statement);
    pips_internal_error("The statement must be the module statement (a sequence of instruction).\n");
    new_module_statement = module_statement;
  }
 
  ifdebug(2) {
    pips_debug(2, "statement with : \n");
    print_statement(new_module_statement);
    pips_debug(2, "end\n");
  }
  return new_module_statement ;
}

References conv_free_ctx(), conv_make_ctx(), copy_statement(), ctx_generate_new_statement_cluster_dependant(), ctx_get_statement_work_on(), ctx_set_return_statement(), ctx_set_statement_work_on(), declaration_statement_p(), finalization(), FOREACH, free_statement(), gen_context_multi_recurse(), gen_core(), get_int_property(), ifdebug, initilization(), insert_statement(), insert_statement_no_matter_what(), make_empty_block_statement(), make_send_receive_conversion(), module, module_statement, MPI_GENERATION_NBR_CLUSTER, pips_debug, pips_internal_error, print_statement(), return_statement_p(), search_copy_communication(), sequence_domain, sequence_statements, sequence_working_false(), STATEMENT, statement_domain, statement_sequence(), statement_sequence_p(), test_domain, and test_working_false().

Referenced by mpi_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

make_send_receive_conversion()

static void make_send_receive_conversion ( statement  stat, ctx_conv_t *  ctx  )

static

Update statement that we work on by replace communication assignment by real MPI_send function and compute the corresponding MPI_receiv that must be done.

if the statement is a sequence add the declaration for all the receive cluster (that have a receive statement)

if the statement stat is copy statement for communication replace the copy statement by the send communication statement

look the parent statement of the AST to duplicate it for the receiver's clusters the duplication of the AST is only done if there is a receive statement (if (!statement_undefined_p(ctx_get_receive_statement(*ctx, i)))) TODO and potentially modify the AST in case of dynamic flow by adding variable and send/receive of this dynamic value \ (This case can only happen if copy_value_of_write is used, but this compilation process is unsure in many point)

Definition at line 1374 of file mpi_conversion.c.

                                                                           {
  pips_debug(5, "begin\n");
  statement st = (statement) gen_get_ancestor_type(statement_domain, stat);
  statement mpi_send_st = statement_undefined;
 
  /**
   * if the statement is a sequence
   *   add the declaration for all the receive cluster (that have a receive statement)
   */
  if (statement_sequence_p(stat)) {
    //Only add the declaration
    push_generated_variable_commenter(mpi_conversion_declaration_commenter);
    for (int i = 0; i < ctx->nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        statement receive_statement = ctx_get_receive_statement(*ctx, i);
        // verify the presence of a receive message
        if (!statement_undefined_p(receive_statement)) {
          receive_statement = make_block_with_stmt_if_not_already(receive_statement);
          if (receive_statement != ctx_get_receive_statement(*ctx, i)) {
            ctx_set_receive_statement(ctx, receive_statement, i);
          }
 
          //Copy all the declaration of the sequence
          // FIXME: Problem with the scope name? same entity declare at many places (but totally different scope so no collision)?
          FOREACH(ENTITY, decl, statement_declarations(stat)) {
            receive_statement = add_declaration_statement(receive_statement, decl);
            statement_declarations(receive_statement) = CONS(ENTITY, decl, statement_declarations(receive_statement));
          }
        }
      }
    }
    pop_generated_variable_commenter();
  }
  /**
   * if the statement stat is copy statement for communication
   *   replace the copy statement by the send communication statement
   */
  else if (assignment_statement_p(stat) && is_distributed_comments(statement_comments(stat))) {
    //if it's a copy-communication statement, the last function called by PIPS was search_copy_communication
    // and this function must have create a send_statement
    mpi_send_st = ctx_get_send_statement(ctx);
    ifdebug(8) {
      pips_debug(8, "mpi_send_st\n");
      print_statement(mpi_send_st);
      pips_debug(8, "ctx_get_statement_work_on(*ctx)\n");
      print_statement(ctx_get_statement_work_on(*ctx));
      pips_debug(8, "end ctx_get_statement_work_on(*ctx)\n");
    }
 
    if (statement_replace_in_root_statement(stat, mpi_send_st, ctx_get_statement_work_on(*ctx)))
      free_statement(stat);
    else
      pips_internal_error("This case never happen.\n");
  }
 
  /**
   * look the parent statement of the AST
   * to duplicate it for the receiver's clusters
   *   the duplication of the AST is only done if there is a receive statement
   *   (if (!statement_undefined_p(ctx_get_receive_statement(*ctx, i))))
   * TODO and potentially modify the AST in case of dynamic flow by adding variable and send/receive of this dynamic value \\
   *      (This case can only happen if copy_value_of_write is used, but this compilation process is unsure in many point)
   */
  if (st != NULL) {
    for (int i = 0; i < ctx->nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        statement receive_statement = ctx_get_receive_statement(*ctx, i);
 
        if (!statement_undefined_p(receive_statement)) {
          switch (instruction_tag(statement_instruction(st))) {
          case is_instruction_sequence:
          {
            // Nothing to do
            pips_internal_error("This case never happen because sequence_working_false always return false\n");
            break;
          }
          case is_instruction_test:
          {
            pips_internal_error("This case never happen because test_working_false always return false\n");
//            test t = statement_test(st);
//            expression cond = test_condition(t);
//            statement new_statement = statement_undefined;
//
//            expression ncond = copy_expression(cond);
//            bool need_more_com = false;     // TO DO: Not implemented yet
//            if (!integer_constant_expression_p(ncond)) {
//              gen_context_recurse(ncond, &i, reference_domain, gen_true, replace_sender_entity_by_receiver_entity_in_reference);
//            }
//            if (need_more_com) {
//              // TO DO modify AST if dynamic
//              //add more send/receive com
//              pips_internal_error("some variables do not exist on receive cluster. Need to send them.\n");
//            }
//
//            statement receive_statement = ctx_get_receive_statement(*ctx, i);
//            if (!statement_undefined_p(receive_statement)) {
//              if (test_true(t)==stat) {
//                new_statement = make_test_statement(
//                    ncond,
//                    receive_statement,
//                    make_empty_block_statement());
//              }
//              else if (test_false(t)==stat) {
//                new_statement = make_test_statement(
//                    not_expression(ncond),
//                    //unary_intrinsic_expression(C_NOT_OPERATOR_NAME, copy_expression(cond)),
//                    receive_statement,
//                    make_empty_block_statement());
//              }
//              else {
//                pips_internal_error("This case never happen;\n");
//              }
//
//              ctx_set_receive_statement(ctx, new_statement, i);
//              new_statement = statement_undefined;
//            }
            break;
          }
          case is_instruction_loop:
          {
            ifdebug(8) {
              pips_debug(8, "is_instruction_loop\n");
              print_statement(st);
              pips_debug(8, "\n");
            }
 
            loop l = statement_loop(st);
            range rg = loop_range(l);
            expression lower = range_lower(rg);
            expression upper = range_upper(rg);
            expression increment = range_increment(rg);
            statement new_statement = statement_undefined;
 
            expression nlower = copy_expression(lower);
            expression nupper = copy_expression(upper);
            expression nincrement = copy_expression(increment);
            bool need_more_com = false;     //TODO: Not implemented yet
            if (!integer_constant_expression_p(nlower))
              gen_context_recurse(nlower, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
            if (!integer_constant_expression_p(nupper))
              gen_context_recurse(nupper, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
            if (!integer_constant_expression_p(nincrement))
              gen_context_recurse(nincrement, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
            if (need_more_com) {
              //TODO modify AST if dynamic
              //add more send/receive com
              pips_internal_error("some variables do not exist on receive cluster. Need to send/receive them.\n");
            }
 
            // Try to aggregate the communication when sending adjacent array element
            syntax snincrement = expression_syntax(nincrement);
            syntax snlower = expression_syntax(nlower);
            syntax snupper = expression_syntax(nupper);
            ifdebug(8) {
              pips_debug(8, "nincrement\n");
              print_expression(nincrement);
              pips_debug(8, "nsincrement\n");
              print_syntax(snincrement);
 
              pips_debug(8, "nlower\n");
              print_expression(nlower);
              pips_debug(8, "snlower\n");
              print_syntax(snlower);
 
              pips_debug(8, "nupper\n");
              print_expression(nupper);
              pips_debug(8, "snupper\n");
              print_syntax(snupper);
            }
 
            // Increment must be +1
            if (expression_constant_p(nincrement) && expression_to_int(nincrement) == 1) {
//              new_statement = generate_receive_from_statement(ctx, stat);
//              new_statement = mpi_recv_ctx(ctx->ctx_mpi, buffer, 1, sender, tag, blocking);
//              mpic_make_mpi_recv(buffer, size, mpitype, source, tag, ctx.mpi_communicator, ctx.mpi_status, ctx.error);
//              if (entity_undefined_p(result)) {
//                mpi_st = call_to_statement(mpi_call);
//              }
//              else {
//                mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
//              }
//              {result =} MPI_Recv(&buffer, size, mpitype, source, tag, communicator, &status);
//              {result =} MPI_Irecv(&buffer, size, mpitype, source, tag, communicator, &request);
              call mpi_call_recv;
              entity result = entity_undefined;
              // receive_statement is : [result =] MPI_[I]Recv(&buffer, size, mpitype, source, tag, communicator, &status);
              //                   or : [result =] MPI_IRecv(&buffer, size, mpitype, source, tag, communicator, &request);
              if (assignment_statement_p(receive_statement)) {
                call assign_call = instruction_call(statement_instruction(receive_statement));
                list args = call_arguments(assign_call);
                expression lhs = EXPRESSION(CAR(args));
                expression rhs = EXPRESSION(CAR(CDR(args)));
                result = expression_to_entity(lhs);
                mpi_call_recv = expression_call(rhs);
              }
              else {
                mpi_call_recv = statement_call(receive_statement);
              }
 
 
              list args = call_arguments(mpi_call_recv);
              expression argbuf = (EXPRESSION(CAR(args)));
              //              expression argsize = (EXPRESSION(CAR(CDR(args))));
//              expression argtype = copy_expression(EXPRESSION(CAR(CDR(CDR(args)))));
//              expression argsource = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(args))))));
//              expression argtag = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(args)))))));
//              expression argcom = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(CDR(args))))))));
//              expression argstatreq = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(CDR(CDR(args)))))))));
              entity lindex = loop_index(l);
              entity argbufent = expression_to_entity(EXPRESSION(CAR(call_arguments((expression_call(argbuf))))));
              ifdebug(8) {
                pips_debug(8, "argbufent\n");
                print_entity_variable(argbufent);
                pips_debug(8, "argbuf\n");
                print_expression(argbuf);
              }
 
              // verify that we work on the most inside array index for C code
              // TODO need to make the inverse for Fortran code...
              call refcall = expression_call(argbuf);
              reference refbuf = expression_reference(EXPRESSION(CAR(call_arguments(refcall))));
              list indices = reference_indices(refbuf);
              ifdebug(8) {
                pips_debug(8, "refbuf\n");
                print_reference(refbuf);
                pips_debug(8, "lindex\n");
                print_entity_variable(lindex);
              }
              //while (indices != NIL && !same_entity_p(lindex, expression_to_entity(EXPRESSION(CAR(indices))))) {
              //  indices = CDR(indices);
              //}
              for (indices = reference_indices(refbuf);
                  indices != NIL && !same_entity_p(lindex, expression_to_entity(EXPRESSION(CAR(indices))));
                  indices = CDR(indices));
 
              if (indices != NIL && same_entity_p(lindex, expression_to_entity(EXPRESSION(CAR(indices))))) {
                // if we are in the most inside array index (C code)
                if (CDR(indices) == NIL
                    // expression_constant_p(argsize) && expression_to_int(argsize) == 1 // Normally is already verify in our case
                    ) {
                  // We can replace the MPI_Receiv to a more aggregate one.
                  // ie. instead of making (for (i=[n;m]) MPI_Recv(a[i])) -> MPI_Recv(a[n:m])
                  expression newtype = copy_expression(EXPRESSION(CAR(CDR(CDR(args)))));
                  expression newsource = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(args))))));
                  expression newtag = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(args)))))));
                  expression newcom = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(CDR(args))))))));
                  expression newstatreq = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(CDR(CDR(args)))))))));
                  expression newbuf = expression_undefined;
                  expression newsize = expression_undefined;
 
                  // Compute the new size of element to communicate
                  if (zero_expression_p(nlower)) {
                    //newsize = copy_expression(nupper); // it's false, we have to add 1 to this number...
                    intptr_t upint;
                    if (expression_integer_value(nupper, &upint))
                      newsize = int_to_expression(upint+1);
                    else
                      newsize = expressions_to_operation(
                          gen_make_list(expression_domain,
                              copy_expression(nupper),
                              int_to_expression(1),
                              NULL),
                          CreateIntrinsic(PLUS_OPERATOR_NAME));
                          //CreateIntrinsic(PLUS_C_OPERATOR_NAME));
                  }
                  else {
                    intptr_t lowint, upint;
                    if (expression_integer_value(nlower, &lowint) && expression_integer_value(nupper, &upint)) {
                      intptr_t newsizeint = upint-lowint+1;
                      if (newsizeint > 0)
                        newsize = int_to_expression(newsizeint);
                      else
                        pips_internal_error("communication of a negative number of elements (%ld)\n"
                            "This case never happen...", newsizeint);
                    }
                    else
                      newsize = expressions_to_operation(
                          gen_make_list(expression_domain,
                              expressions_to_operation(gen_make_list(expression_domain, copy_expression(nlower), copy_expression(nupper), NULL),
                                  CreateIntrinsic(MINUS_OPERATOR_NAME)),
                                  //CreateIntrinsic(MINUS_C_OPERATOR_NAME)),
                              int_to_expression(1),
                              NULL),
                          CreateIntrinsic(PLUS_OPERATOR_NAME));
                          //CreateIntrinsic(PLUS_C_OPERATOR_NAME));
                  }
 
                  // Compute the new first array element to communicate
                  list oldindices = reference_indices(refbuf);
                  list newindices = NIL;
                  while (oldindices != NIL) {
                    if (same_entity_p(lindex, expression_to_entity(EXPRESSION(CAR(oldindices)))))
                      newindices = CONS(EXPRESSION, copy_expression(nlower), newindices);
                      //newindices = gen_append(CONS(EXPRESSION, int_to_expression(0), NIL), newindices);
                    else
                      newindices = CONS(EXPRESSION, EXPRESSION(CAR(oldindices)), newindices);
                      //newindices = gen_append(CONS(EXPRESSION, EXPRESSION(CAR(oldindices)), NIL), newindices);
                    oldindices = CDR(oldindices);
                  }
                  newindices = gen_nreverse(newindices);
                  newbuf = make_address_of_expression(make_entity_expression(argbufent, newindices));
                  //newbuf = make_call_expression(call_function(expression_call(argbuf)), make_entity_expression(argbufent, newindices));
 
                  ifdebug(8) {
                    pips_debug(8, "newsize\n");
                    print_expression(newsize);
                    expression_consistent_p(newsize);
                    pips_debug(8, "newbuf\n");
                    print_expression(newbuf);
                  }
 
                  //Generate the new aggregate receive statement in MPI
                  call receive_call;
                  list newarg = gen_make_list(expression_domain, newbuf, newsize, newtype, newsource, newtag, newcom, newstatreq, NULL);
                  receive_call = make_call(call_function(mpi_call_recv), newarg);
                  if (entity_undefined_p(result)) {
                    new_statement = call_to_statement(receive_call);
                  }
                  else {
                    new_statement = make_assign_statement(entity_to_expression(result), call_to_expression(receive_call));
                  }
 
                  //Replace the the communication for the sender
                  call send_call, mpi_send_call;
                  entity result_send = entity_undefined;
                  if (assignment_statement_p(mpi_send_st)) {
                    call assign_call = instruction_call(statement_instruction(mpi_send_st));
                    list args = call_arguments(assign_call);
                    expression lhs = EXPRESSION(CAR(args));
                    expression rhs = EXPRESSION(CAR(CDR(args)));
                    result_send = expression_to_entity(lhs);
                    mpi_send_call = expression_call(rhs);
                  }
                  else {
                    mpi_send_call = statement_call(mpi_send_st);
                  }
 
                  list sendarg;
                  entity sendbufent = expression_to_entity(EXPRESSION(CAR(call_arguments((expression_call(EXPRESSION(CAR(call_arguments(mpi_send_call)))))))));
                  expression sendreq = expression_undefined;
                  expression sendbuf = make_address_of_expression(make_entity_expression(sendbufent, gen_full_copy_list(newindices)));
                  expression sendsize = copy_expression(newsize);
                  expression sendtype = copy_expression(newtype);
                  expression senddest = int_to_expression(i);
                  expression sendtag = copy_expression(newtag);
                  expression sendcom = copy_expression(newcom);
                  // expression sendtype = copy_expression(EXPRESSION(CAR(CDR(CDR(call_arguments(mpi_send_call))))));
                  // expression senddest = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(call_arguments(mpi_send_call)))))));
                  // expression sendtag = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(call_arguments(mpi_send_call))))))));
                  // expression sendcom = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(CDR(call_arguments(mpi_send_call)))))))));
                  if (same_entity_p(entity_intrinsic(MPI_SEND_FUNCTION_NAME), call_function(mpi_send_call))) {
                    //MPI_Send
                    sendarg = gen_make_list(expression_domain, sendbuf, sendsize, sendtype, senddest, sendtag, sendcom, NULL);
                  }
                  else {
                    //MPI_Isend
                    sendreq = copy_expression(EXPRESSION(CAR(CDR(CDR(CDR(CDR(CDR(CDR(call_arguments(mpi_send_call))))))))));
                    sendarg = gen_make_list(expression_domain, sendbuf, sendsize, sendtype, senddest, sendtag, sendcom, sendreq, NULL);
                  }
                  send_call = make_call(call_function(mpi_send_call), sendarg);
 
 
                  statement send_statement;
                  if (entity_undefined_p(result_send)) {
                    send_statement = call_to_statement(send_call);
                  }
                  else {
                    send_statement = make_assign_statement(entity_to_expression(result_send), call_to_expression(send_call));
                  }
 
                  if (!statement_replace_in_root_statement(st, send_statement, ctx_get_statement_work_on(*ctx)))
                    pips_internal_error("This case never happen.\n");
 
                  ifdebug(5) {
                    pips_debug(5, "send_statement\n");
                    print_statement(send_statement);
                    statement_consistent_p(send_statement);
                    pips_debug(5, "\n");
                  }
 
 
                  // clean the memory
                  free_statement(receive_statement);
                  receive_statement = statement_undefined;
                  free_statement(mpi_send_st);
                  mpi_send_st = statement_undefined;
                  free_expression(nlower);
                  free_expression(nupper);
                  free_expression(nincrement);
                }
                // else we have to verify that each more index are 0,
                // and the total size of the MPI_[I]Recv is equal to the size of all the inside array...
                else {
                  // TODO: implementation for multidimensional array communication
                  // Not implemented yet...
                  // Does an array resizing can be a issue ?
                  //   For instance the array size for the reception is contiguous but not for the sender...
                  // How to implement it:
                  // We have to verify that the loop concern the last (resp. first for fortran) index of the array to communicate
                  //   that all the inner (resp. outer) dimension start at 0 and communicate all there dimension elements
                  //   that the current dimension that we want to communicate is on all the dimension array and not just part of it
                  //     ie. that the loop start at 0 and end at the size of the array.
                  // Then replace the start of the array to communicate by a 0 for the concern dimension
                  //   and multiply the size to communicate by the size of the current dimension that it's treated.
                  // Do not forget to replace the com for the sender
                  // Do not forget to clean the memory
                  new_statement = make_loop_statement(
                      loop_index(l),
                      nlower, nupper, nincrement,
                      receive_statement);
                }
              }
            }
            // if (statement_undefined_p(new_statement)) {
            else {
              new_statement = make_loop_statement(
                  loop_index(l),
                  nlower, nupper, nincrement,
                  receive_statement);
            }
            ctx_set_receive_statement(ctx, new_statement, i);
 
            ifdebug(5) {
              pips_debug(5, "receive_statement\n");
              print_statement(receive_statement);
              statement_consistent_p(receive_statement);
              pips_debug(5, "new_statement\n");
              print_statement(new_statement);
              statement_consistent_p(new_statement);
              pips_debug(5, "\n");
            }
            //new_statement = statement_undefined;
            break;
          }
          case is_instruction_whileloop:
          {
            ifdebug(8) {
              pips_debug(8, "is_instruction_whileloop\n");
              print_statement(st);
              pips_debug(8, "\n");
            }
 
            whileloop l = statement_whileloop(st);
            expression cond = whileloop_condition(l);
            statement new_statement = statement_undefined;
 
            expression ncond = copy_expression(cond);
            bool need_more_com = false;     //TODO: Not implemented yet
            if (!integer_constant_expression_p(ncond))
              gen_context_recurse(ncond, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
            if (need_more_com) {
              //TODO modify AST if dynamic
              //add more send/receive com
              pips_internal_error("some variables do not exist on receive cluster. Need to send/receive them.\n");
            }
 
            new_statement = make_whileloop_statement(
                ncond,
                receive_statement,
                STATEMENT_NUMBER_UNDEFINED,
                evaluation_before_p(whileloop_evaluation(l)));
            ctx_set_receive_statement(ctx, new_statement, i);
            //new_statement = statement_undefined;
            break;
          }
          case is_instruction_forloop:
          {
            ifdebug(8) {
              pips_debug(8, "is_instruction_whileloop\n");
              print_statement(st);
              pips_debug(8, "\n");
            }
 
            forloop l = statement_forloop(st);
            expression init = forloop_initialization(l);
            expression cond = forloop_condition(l);
            expression incr = forloop_increment(l);
            statement new_statement = statement_undefined;
 
            expression ninit = copy_expression(init);
            expression ncond = copy_expression(cond);
            expression nincr = copy_expression(incr);
            bool need_more_com = false;     //TODO: Not implemented yet
            if (!integer_constant_expression_p(ninit))
              gen_context_recurse(ninit, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
            if (!integer_constant_expression_p(ncond))
              gen_context_recurse(ncond, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
            if (!integer_constant_expression_p(nincr))
              gen_context_recurse(nincr, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
            if (need_more_com) {
              //TODO modify AST if dynamic
              //add more send/receive com
              pips_internal_error("some variables do not exist on receive cluster. Need to send them.\n");
            }
 
            new_statement = make_forloop_statement(
                ninit,
                ncond,
                nincr,
                receive_statement);
            ctx_set_receive_statement(ctx, new_statement, i);
            //new_statement = statement_undefined;
            break;
          }
          case is_instruction_call:
          //{
          //  break;
          //}
          case is_instruction_unstructured:
          case is_instruction_multitest:
          case is_instruction_goto:
          case is_instruction_expression:
            pips_internal_error("This case never happen? tag=%d\n", instruction_tag(statement_instruction(st)));
            break;
          default:
            pips_internal_error("This tag doesn't exist: %d\n", instruction_tag(statement_instruction(st)));
            break;
          }
        }
      }
    }
  }
  pips_debug(5, "end\n");
}

References add_declaration_statement(), assignment_statement_p(), call_arguments, call_function, call_to_expression(), call_to_statement, CAR, CDR, CONS, copy_expression(), CreateIntrinsic(), ctx_get_receive_statement(), ctx_get_send_statement(), ctx_get_statement_work_on(), ctx_set_receive_statement(), ctx_conv::current_cluster, ENTITY, entity_intrinsic(), entity_to_expression(), entity_undefined, entity_undefined_p, evaluation_before_p, EXPRESSION, expression_call(), expression_consistent_p(), expression_constant_p(), expression_domain, expression_integer_value(), expression_reference(), expression_syntax, expression_to_entity(), expression_to_int(), expression_undefined, expressions_to_operation(), FOREACH, forloop_condition, forloop_increment, forloop_initialization, free_expression(), free_statement(), gen_context_recurse, gen_full_copy_list(), gen_get_ancestor_type, gen_make_list(), gen_nreverse(), gen_true2(), ifdebug, indices, init, instruction_call, instruction_tag, int_to_expression(), integer_constant_expression_p(), intptr_t, is_distributed_comments(), is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_multitest, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, loop_index, loop_range, make_address_of_expression(), make_assign_statement(), make_block_with_stmt_if_not_already(), make_call(), make_entity_expression(), make_forloop_statement(), make_loop_statement(), make_whileloop_statement(), MINUS_OPERATOR_NAME, mpi_conversion_declaration_commenter(), MPI_SEND_FUNCTION_NAME, ctx_conv::nbr_cluster, NIL, pips_debug, pips_internal_error, PLUS_OPERATOR_NAME, pop_generated_variable_commenter(), print_entity_variable(), print_expression(), print_reference(), print_statement(), print_syntax(), push_generated_variable_commenter(), range_increment, range_lower, range_upper, reference_domain, reference_indices, replace_sender_entity_by_receiver_entity_in_reference(), same_entity_p(), statement_call(), statement_comments, statement_consistent_p(), statement_declarations, statement_domain, statement_forloop(), statement_instruction, statement_loop(), STATEMENT_NUMBER_UNDEFINED, statement_replace_in_root_statement(), statement_sequence_p(), statement_undefined, statement_undefined_p, statement_whileloop(), whileloop_condition, whileloop_evaluation, and zero_expression_p().

Referenced by make_mpi_conversion(), sequence_working_false(), and test_working_false().

Here is the caller graph for this function:

mpi_comm_rank_ctx()

static statement mpi_comm_rank_ctx ( const ctx_mpi_t  ctx )

static

Definition at line 554 of file mpi_conversion.c.

                                                        {
  return mpic_make_mpi_comm_rank(ctx.mpi_communicator, ctx.rank, ctx.error);
}

References ctx_mpi::error, ctx_mpi::mpi_communicator, mpic_make_mpi_comm_rank(), and ctx_mpi::rank.

Referenced by initilization().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_comm_size_ctx()

static statement mpi_comm_size_ctx ( const ctx_mpi_t  ctx )

static

Definition at line 550 of file mpi_conversion.c.

                                                        {
  return mpic_make_mpi_comm_size(ctx.mpi_communicator, ctx.size, ctx.error);
}

References ctx_mpi::error, ctx_mpi::mpi_communicator, mpic_make_mpi_comm_size(), and ctx_mpi::size.

Referenced by initilization().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_conversion()

bool mpi_conversion

(

const char *

module_name

)

PIPS pass.

mpi_conversion.c

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name

odule_name

Definition at line 1989 of file mpi_conversion.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));
 
  set_ordering_to_statement(module_statement);
 
  //-- get dependencies --//
//  if(use_points_to) {
//    set_pointer_info_kind(with_points_to); //enough?
//  }
  set_parallel_task_mapping((statement_task)
      db_get_memory_resource(DBR_TASK, module_name, true));
 
  //-- Make the job -- //
  module_statement = make_mpi_conversion(module, module_statement);
 
  pips_assert("Statement should be OK after...",
      statement_consistent_p(module_statement));
 
  // Removed useless block created by the insert_statement
  unspaghettify_statement(module_statement);
 
  /* Reorder the module, because some statements have been added.
     Well, the order on the remaining statements should be the same,
     but by reordering the statements, the number are consecutive. Just
     for pretty print... :-) */
  module_reorder(module_statement);
 
  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);
 
  reset_ordering_to_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(), make_mpi_conversion(), module, module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_parallel_task_mapping(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_parallel_task_mapping(), statement_consistent_p(), strdup(), and unspaghettify_statement().

Here is the call graph for this function:

mpi_conversion_declaration_commenter()

static string mpi_conversion_declaration_commenter ( __attribute__((unused)) entity  e )

static

Pass: MPI_CONVERSION Debug mode: MPI_GENERATION_DEBUG_LEVEL Properties used:

• MPI_NBR_CLUSTER
• MPI_DUPLICATE_VARIABLE_PREFIX Resource needed:
• DBR_TASK

Definition at line 63 of file mpi_conversion.c.

                                                                                     {
  return strdup(COMMENT_MPI_CONVERSION);
}

References COMMENT_MPI_CONVERSION, and strdup().

Referenced by initilization(), and make_send_receive_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_finalize_ctx()

static statement mpi_finalize_ctx ( const ctx_mpi_t  ctx )

static

Definition at line 564 of file mpi_conversion.c.

                                                       {
  return mpic_make_mpi_finalize(ctx.error);
}

References ctx_mpi::error, and mpic_make_mpi_finalize().

Referenced by finalization().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_free_ctx()

static void mpi_free_ctx ( __attribute__((__unused__)) ctx_mpi_t *  ctx )

static

Definition at line 545 of file mpi_conversion.c.

                                                                       {
  //Nothing to do
  return;
}

Referenced by conv_free_ctx().

Here is the caller graph for this function:

mpi_init_ctx()

static statement mpi_init_ctx ( const ctx_mpi_t  ctx )

static

Definition at line 558 of file mpi_conversion.c.

                                                   {
  entity argc = gen_find_tabulated("main:argc", entity_domain);
  entity argv = gen_find_tabulated("main:argv", entity_domain);
  return mpic_make_mpi_init(ctx.error, argc, argv);
}

References entity_domain, ctx_mpi::error, gen_find_tabulated(), and mpic_make_mpi_init().

Referenced by initilization().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_make_ctx()

static ctx_mpi_t mpi_make_ctx ( entity  module )

static

urrentOffsetOfArea(area, ctx.mpi_communicator)

Definition at line 517 of file mpi_conversion.c.

                                             {
  ctx_mpi_t ctx;
  ctx.size = make_new_scalar_variable_with_prefix("size", module, MakeBasic(is_basic_int));
  ctx.rank = make_new_scalar_variable_with_prefix("rank", module, MakeBasic(is_basic_int));
 
  ctx.mpi_communicator = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, MPI_COMM_WORLD_STRING);
  if (type_undefined_p(entity_type(ctx.mpi_communicator))) {
    entity_type(ctx.mpi_communicator) = mpi_type_mpi_comm();
  }
  if (storage_undefined_p(entity_storage(ctx.mpi_communicator))) {
    //FIXME global variable, what kind of storage?
    // It's certainly not the good storage here...
    const char* module_name = module_local_name(module);
    entity area = FindEntity(module_name, STACK_AREA_LOCAL_NAME);
    entity_storage(ctx.mpi_communicator) =
//        make_storage_rom();
        make_storage_ram(make_ram(module, area, 0/*CurrentOffsetOfArea(area, ctx.mpi_communicator)*/, NIL));
  }
 
  ctx.mpi_status = make_new_scalar_variable_with_prefix("status", module, MakeBasic(is_basic_int));
  entity_type(ctx.mpi_status) = mpi_type_mpi_status();
 
  ctx.mpi_request = make_new_scalar_variable_with_prefix("request", module, MakeBasic(is_basic_int));
  entity_type(ctx.mpi_request) = mpi_type_mpi_request();
 
  ctx.error = entity_undefined;
  return ctx;
}

References entity_storage, entity_type, entity_undefined, ctx_mpi::error, FindEntity(), FindOrCreateEntity(), is_basic_int, make_new_scalar_variable_with_prefix(), make_ram(), make_storage_ram(), MakeBasic(), module, module_local_name(), module_name(), MPI_COMM_WORLD_STRING, ctx_mpi::mpi_communicator, ctx_mpi::mpi_request, ctx_mpi::mpi_status, mpi_type_mpi_comm(), mpi_type_mpi_request(), mpi_type_mpi_status(), NIL, ctx_mpi::rank, ctx_mpi::size, STACK_AREA_LOCAL_NAME, storage_undefined_p, TOP_LEVEL_MODULE_NAME, and type_undefined_p.

Referenced by conv_make_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_recv_ctx()

static statement mpi_recv_ctx ( const ctx_mpi_t  ctx, expression  buffer, int  size, int  source, int  tag, bool  blocking  )

static

TODO do the same for Ssend, Rsend, Bsend.

Definition at line 595 of file mpi_conversion.c.

                                                                                                                    {
  entity mpitype = entity_undefined;
  basic bas = variable_basic(type_variable(entity_type(expression_to_entity(buffer))));
  switch(basic_tag(bas)){
  case is_basic_int:
    //don't know what to put for size (so 100 for the moment...)
    mpitype = make_constant_entity("MPI_INT", is_basic_string, 100);
    break;
  case is_basic_float:
    //don't know what to put for size (so 100 for the moment...)
//    mpitype = make_constant_entity("MPI_FLOAT", is_basic_string, 100);
    mpitype = make_constant_entity("MPI_DOUBLE", is_basic_string, 100);
    break;
  default:
    pips_user_warning("type %s not handled yet in MPI\n", basic_to_string(bas));
    break;
  }
 
  if (blocking)
    return mpic_make_mpi_recv(buffer, size, mpitype, source, tag, ctx.mpi_communicator, ctx.mpi_status, ctx.error);
  else
    return mpic_make_mpi_irecv(buffer, size, mpitype, source, tag, ctx.mpi_communicator, ctx.mpi_request, ctx.error);
}

References basic_tag, basic_to_string(), buffer, entity_type, entity_undefined, ctx_mpi::error, expression_to_entity(), is_basic_float, is_basic_int, is_basic_string, make_constant_entity(), ctx_mpi::mpi_communicator, ctx_mpi::mpi_request, ctx_mpi::mpi_status, mpic_make_mpi_irecv(), mpic_make_mpi_recv(), pips_user_warning, type_variable, and variable_basic.

Referenced by generate_receive_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_send_ctx()

static statement mpi_send_ctx ( const ctx_mpi_t  ctx, expression  buffer, int  size, int  dest, int  tag, bool  blocking  )

static

Definition at line 568 of file mpi_conversion.c.

                                                                                                                  {
  entity mpitype = entity_undefined;
  basic bas = variable_basic(type_variable(entity_type(expression_to_entity(buffer))));
  switch(basic_tag(bas)){
  case is_basic_int:
    //don't know what to put for size (so 100 for the moment...)
    mpitype = make_constant_entity("MPI_INT", is_basic_string, 100);
    break;
  case is_basic_float:
    //don't know what to put for size (so 100 for the moment...)
//    mpitype = make_constant_entity("MPI_FLOAT", is_basic_string, 100);
    mpitype = make_constant_entity("MPI_DOUBLE", is_basic_string, 100);
    break;
  default:
    pips_user_warning("type %s not handled yet in MPI\n", basic_to_string(bas));
    break;
  }
 
  if (!blocking)
    return mpic_make_mpi_isend(buffer, size, mpitype, dest, tag, ctx.mpi_communicator, ctx.mpi_request, ctx.error);
  else
    return mpic_make_mpi_send(buffer, size, mpitype, dest, tag, ctx.mpi_communicator, ctx.error);
}

References basic_tag, basic_to_string(), buffer, entity_type, entity_undefined, ctx_mpi::error, expression_to_entity(), is_basic_float, is_basic_int, is_basic_string, make_constant_entity(), ctx_mpi::mpi_communicator, ctx_mpi::mpi_request, mpic_make_mpi_isend(), mpic_make_mpi_send(), pips_user_warning, type_variable, and variable_basic.

Referenced by generate_send_from_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_type_mpi_comm()

static type mpi_type_mpi_comm ( )

static

return the type for MPI communicator: MPI_Comm

Definition at line 429 of file mpi_conversion.c.

                                {
  entity comm = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, MPI_COMM);
  if(storage_undefined_p(entity_storage(comm))) {
    entity_storage(comm) = make_storage_rom();
    put_new_typedef(MPI_COMM);
  }
  type comm_t = MakeTypeVariable(make_basic_typedef(comm), NIL);
  if(type_undefined_p(entity_type(comm))) {
    entity_type(comm) = ImplicitType(comm);
  }
  return comm_t;
}

References entity_storage, entity_type, FindOrCreateEntity(), ImplicitType(), make_basic_typedef(), make_storage_rom(), MakeTypeVariable(), MPI_COMM, NIL, put_new_typedef(), storage_undefined_p, TOP_LEVEL_MODULE_NAME, and type_undefined_p.

Referenced by mpi_make_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_type_mpi_request()

static type mpi_type_mpi_request ( )

static

return the type for MPI request: MPI_Request

Definition at line 463 of file mpi_conversion.c.

                                   {
  entity req =   FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, MPI_REQUEST);
  if(storage_undefined_p(entity_storage(req))) {
    entity_storage(req) = make_storage_rom();
    put_new_typedef(MPI_REQUEST);
  }
  type req_t =MakeTypeVariable(make_basic_typedef(req), NIL);
  if(type_undefined_p(entity_type(req))) {
    entity_type(req) = ImplicitType(req);
  }
  return req_t;
}

References entity_storage, entity_type, FindOrCreateEntity(), ImplicitType(), make_basic_typedef(), make_storage_rom(), MakeTypeVariable(), MPI_REQUEST, NIL, put_new_typedef(), storage_undefined_p, TOP_LEVEL_MODULE_NAME, and type_undefined_p.

Referenced by mpi_make_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpi_type_mpi_status()

static type mpi_type_mpi_status ( )

static

return the type for MPI status: MPI_Status

Definition at line 446 of file mpi_conversion.c.

                                  {
  entity stat = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, MPI_STATUS);
  if(storage_undefined_p(entity_storage(stat))) {
    entity_storage(stat) = make_storage_rom();
    put_new_typedef(MPI_STATUS);
  }
  type stat_t = MakeTypeVariable(make_basic_typedef(stat), NIL);
  if(type_undefined_p(entity_type(stat))) {
    entity_type(stat) = ImplicitType(stat);
  }
  return stat_t;
}

References entity_storage, entity_type, FindOrCreateEntity(), ImplicitType(), make_basic_typedef(), make_storage_rom(), MakeTypeVariable(), MPI_STATUS, NIL, put_new_typedef(), storage_undefined_p, TOP_LEVEL_MODULE_NAME, and type_undefined_p.

Referenced by mpi_make_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_args_mpi_send_or_receiv()

static list mpic_make_args_mpi_send_or_receiv ( expression  buffer, int  size, entity  mpitype, int  ds, int  tag, entity  communicator, entity  status, entity  request  )

static

tatic statement mpifortran_make_mpi_finalize(entity result) { list args = CONS(EXPRESSION, make_entity_expression(result, NIL), NIL); args = gen_nreverse(args); statement mpi_st = make_call_statement(MPI_FINALIZE_FUNCTION_NAME, args, entity_undefined, string_undefined); return mpi_st; }

make a list of expression that will be use as argument for MPI send/receive functions ds is the destination or the source depend of a send or receive function (&buffer, size, mpitype, ds, tag, communicator{, status/request})

Definition at line 192 of file mpi_conversion.c.

{
  list args = NIL;
 
  args = CONS(EXPRESSION, make_address_of_expression(buffer), args);
  args = CONS(EXPRESSION, int_to_expression(size), args);
 
  pips_assert("mpitype must defined.\n", !entity_undefined_p(mpitype));
  args = CONS(EXPRESSION, make_entity_expression(mpitype, NIL), args);
 
//  basic bas = variable_basic(type_variable(entity_type(expression_to_entity(buffer))));
//  switch(basic_tag(bas)){
//  case is_basic_int:
//    //don't know what to put for size (so 100 for the moment...)
//    args = CONS(EXPRESSION, make_entity_expression(make_constant_entity("MPI_INT", is_basic_string, 100), NIL), args);
//    break;
//  case is_basic_float:
//    //don't know what to put for size (so 100 for the moment...)
//    args = CONS(EXPRESSION, make_entity_expression(make_constant_entity("MPI_FLOAT", is_basic_string, 100), NIL), args);
//    break;
//  default:
//    pips_user_warning("type %s not handled yet in MPI\n", basic_to_string(bas));
//    break;
//  }
 
  args = CONS(EXPRESSION, int_to_expression(ds), args);
  args = CONS(EXPRESSION, int_to_expression(tag), args);
 
  args = CONS(EXPRESSION, make_entity_expression(communicator, NIL), args);
 
  if (!entity_undefined_p(status) && !entity_undefined_p(request)) {
    pips_internal_error("MPI_Status and MPI_Request can't be use at the same time\n"
        "  use MPI_status for blocking function\n"
        "  use MPI_Request for non-blocking function\n");
  }
  else if (!entity_undefined_p(request)) {
    args = CONS(EXPRESSION, make_address_of_expression(make_entity_expression(request, NIL)), args);
  }
  else if (!entity_undefined_p(status)) {
    args = CONS(EXPRESSION, make_address_of_expression(make_entity_expression(status, NIL)), args);
  }
 
  args = gen_nreverse(args);
  return args;
}

References buffer, CONS, entity_undefined_p, EXPRESSION, gen_nreverse(), int_to_expression(), make_address_of_expression(), make_entity_expression(), NIL, pips_assert, and pips_internal_error.

Referenced by mpic_make_generic_mpi_receive_call(), and mpic_make_generic_mpi_send_call().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_generic_mpi_receive_call()

static call mpic_make_generic_mpi_receive_call ( expression  buffer, int  size, entity  mpitype, int  dest, int  tag, entity  communicator, entity  status, entity  request  )

static

Definition at line 292 of file mpi_conversion.c.

{
  if (!entity_undefined_p(status) && !entity_undefined_p(request))
    pips_internal_error("MPI_Status and MPI_Request can't be use at the same time for MPI_Recv/MPI_Irecv instruction\n"
        "  use MPI_status for blocking receive (MPI_Recv)\n"
        "  use MPI_Request for non-blocking receive (MPI_Irecv)\n");
  else if (entity_undefined_p(status) && entity_undefined_p(request))
    pips_internal_error("MPI_Status xor MPI_Request must be use present for MPI_Recv/MPI_Irecv instruction\n"
        "  use MPI_status for blocking receive (MPI_Recv)\n"
        "  use MPI_Request for non-blocking receive (MPI_Irecv)\n");
 
  list args = mpic_make_args_mpi_send_or_receiv(buffer, size, mpitype, dest, tag, communicator, status, request);
 
  entity called_function = entity_undefined;
  if (entity_undefined_p(request))
    called_function = entity_intrinsic(MPI_RECV_FUNCTION_NAME);
  else
    called_function = entity_intrinsic(MPI_IRECV_FUNCTION_NAME);
 
  call mpi_call = make_call(called_function, args);
  return mpi_call;
}

References buffer, entity_intrinsic(), entity_undefined, entity_undefined_p, make_call(), MPI_IRECV_FUNCTION_NAME, MPI_RECV_FUNCTION_NAME, mpic_make_args_mpi_send_or_receiv(), and pips_internal_error.

Referenced by mpic_make_mpi_irecv(), and mpic_make_mpi_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_generic_mpi_send_call()

static call mpic_make_generic_mpi_send_call ( expression  buffer, int  size, entity  mpitype, int  dest, int  tag, entity  communicator, entity  request, enum mpi_communication_mode  mode  )

static

Definition at line 246 of file mpi_conversion.c.

{
  list args = mpic_make_args_mpi_send_or_receiv(buffer, size, mpitype, dest, tag, communicator, entity_undefined, request);
 
  entity called_function = entity_undefined;
  switch (mode) {
  case mpi_communication_synchronous_mode:
    if (entity_undefined_p(request))
      called_function = entity_intrinsic(MPI_SSEND_FUNCTION_NAME);
    else
      called_function = entity_intrinsic(MPI_ISSEND_FUNCTION_NAME);
    break;
  case mpi_communication_ready_mode:
    if (entity_undefined_p(request))
      called_function = entity_intrinsic(MPI_RSEND_FUNCTION_NAME);
    else
      called_function = entity_intrinsic(MPI_IRSEND_FUNCTION_NAME);
    break;
  case mpi_communication_buffered_mode:
    if (entity_undefined_p(request))
      called_function = entity_intrinsic(MPI_BSEND_FUNCTION_NAME);
    else
      called_function = entity_intrinsic(MPI_IBSEND_FUNCTION_NAME);
    break;
  case mpi_communication_default_mode:
  default:
    if (entity_undefined_p(request))
      called_function = entity_intrinsic(MPI_SEND_FUNCTION_NAME);
    else
      called_function = entity_intrinsic(MPI_ISEND_FUNCTION_NAME);
    break;
  }
 
  call mpi_call = make_call(called_function, args);
  return mpi_call;
}

References buffer, entity_intrinsic(), entity_undefined, entity_undefined_p, make_call(), MPI_BSEND_FUNCTION_NAME, mpi_communication_buffered_mode, mpi_communication_default_mode, mpi_communication_ready_mode, mpi_communication_synchronous_mode, MPI_IBSEND_FUNCTION_NAME, MPI_IRSEND_FUNCTION_NAME, MPI_ISEND_FUNCTION_NAME, MPI_ISSEND_FUNCTION_NAME, MPI_RSEND_FUNCTION_NAME, MPI_SEND_FUNCTION_NAME, MPI_SSEND_FUNCTION_NAME, and mpic_make_args_mpi_send_or_receiv().

Referenced by mpic_make_mpi_isend(), and mpic_make_mpi_send().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_comm_rank()

static statement mpic_make_mpi_comm_rank ( entity  communicator, entity  rank, entity  result  )

static

generate statement: MPI_Comm_rank(communicator, &rank); or result = MPI_Comm_rank(communicator, &rank);

Definition at line 114 of file mpi_conversion.c.

                                                                                          {
  list args = NIL;
  args = CONS(EXPRESSION, make_entity_expression(communicator, NIL), args);
  args = CONS(EXPRESSION, make_address_of_expression(make_entity_expression(rank, NIL)), args);
  args = gen_nreverse(args);
  entity called_function = entity_intrinsic(MPI_COMM_RANK_FUNCTION_NAME);
  call mpi_call = make_call(called_function, args);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References call_to_expression(), call_to_statement, CONS, entity_intrinsic(), entity_to_expression(), entity_undefined_p, EXPRESSION, gen_nreverse(), make_address_of_expression(), make_assign_statement(), make_call(), make_entity_expression(), MPI_COMM_RANK_FUNCTION_NAME, NIL, rank, and statement_undefined.

Referenced by mpi_comm_rank_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_comm_size()

static statement mpic_make_mpi_comm_size ( entity  communicator, entity  size, entity  result  )

static

Functions to generate standard MPI function statement Can maybe also make function to return MPI function like instruction instead of statement to be more flexible? Only C version are made, for Fortran version, have to add an error manager variable (instead return result in C than represent possible error, add it in call function, cf MPI doc) All these functions can be general and move into a MPI manager? In that case only unstatic function that return statement or type.

generate statement: MPI_Comm_size(communicator, &size); or result = MPI_Comm_size(communicator, &size);

Definition at line 91 of file mpi_conversion.c.

                                                                                          {
  list args = NIL;
  args = CONS(EXPRESSION, make_entity_expression(communicator, NIL), args);
  args = CONS(EXPRESSION, make_address_of_expression(make_entity_expression(size, NIL)), args);
  args = gen_nreverse(args);
  entity called_function = entity_intrinsic(MPI_COMM_SIZE_FUNCTION_NAME);
  call mpi_call = make_call(called_function, args);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References call_to_expression(), call_to_statement, CONS, entity_intrinsic(), entity_to_expression(), entity_undefined_p, EXPRESSION, gen_nreverse(), make_address_of_expression(), make_assign_statement(), make_call(), make_entity_expression(), MPI_COMM_SIZE_FUNCTION_NAME, NIL, and statement_undefined.

Referenced by mpi_comm_size_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_finalize()

static statement mpic_make_mpi_finalize ( entity  result )

static

generate statement: MPI_Finalize(); or result = MPI_Finalize();

Definition at line 165 of file mpi_conversion.c.

                                                       {
  list args = NIL;
  args = gen_nreverse(args);
  entity called_function = entity_intrinsic(MPI_FINALIZE_FUNCTION_NAME);
  call mpi_call = make_call(called_function, args);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References call_to_expression(), call_to_statement, entity_intrinsic(), entity_to_expression(), entity_undefined_p, gen_nreverse(), make_assign_statement(), make_call(), MPI_FINALIZE_FUNCTION_NAME, NIL, and statement_undefined.

Referenced by mpi_finalize_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_init()

static statement mpic_make_mpi_init ( entity  result, entity  argc, entity  argv  )

static

argc and argv must be defined generate statement: MPI_Init(&argc, &argv); or result = MPI_Init(&argc, &argv);

Definition at line 138 of file mpi_conversion.c.

                                                                             {
  list args = NIL;
  if (argc == NULL || entity_undefined_p(argc) || entity_undefined_p(argv)) {
    pips_user_error("argc and argv must be defined\n");
    return statement_undefined;
  }
  args = CONS(EXPRESSION, make_address_of_expression(make_entity_expression(argc, NIL)), args);
  args = CONS(EXPRESSION, make_address_of_expression(make_entity_expression(argv, NIL)), args);
  args = gen_nreverse(args);
  entity called_function = entity_intrinsic(MPI_INIT_FUNCTION_NAME);
  call mpi_call = make_call(called_function, args);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References call_to_expression(), call_to_statement, CONS, entity_intrinsic(), entity_to_expression(), entity_undefined_p, EXPRESSION, gen_nreverse(), make_address_of_expression(), make_assign_statement(), make_call(), make_entity_expression(), MPI_INIT_FUNCTION_NAME, NIL, pips_user_error, and statement_undefined.

Referenced by mpi_init_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_irecv()

static statement mpic_make_mpi_irecv ( expression  buffer, int  size, entity  mpitype, int  source, int  tag, entity  communicator, entity  request, entity  result  )

static

generate statement: {result =} MPI_Irecv(&buffer, size, mpitype, source, tag, communicator, &request);

Definition at line 404 of file mpi_conversion.c.

{
  call mpi_call = mpic_make_generic_mpi_receive_call(buffer, size, mpitype, source, tag, communicator, entity_undefined, request);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References buffer, call_to_expression(), call_to_statement, entity_to_expression(), entity_undefined, entity_undefined_p, make_assign_statement(), mpic_make_generic_mpi_receive_call(), and statement_undefined.

Referenced by mpi_recv_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_isend()

static statement mpic_make_mpi_isend ( expression  buffer, int  size, entity  mpitype, int  dest, int  tag, entity  communicator, entity  request, entity  result  )

static

generate statement: {result =} MPI_Isend(&buffer, size, mpitype, dest, tag, communicator, &request);

Definition at line 352 of file mpi_conversion.c.

{
  call mpi_call = mpic_make_generic_mpi_send_call(buffer, size, mpitype, dest, tag, communicator, request, mpi_communication_default_mode);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References buffer, call_to_expression(), call_to_statement, entity_to_expression(), entity_undefined_p, make_assign_statement(), mpi_communication_default_mode, mpic_make_generic_mpi_send_call(), and statement_undefined.

Referenced by mpi_send_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_recv()

static statement mpic_make_mpi_recv ( expression  buffer, int  size, entity  mpitype, int  source, int  tag, entity  communicator, entity  status, entity  result  )

static

TODO do the same for MPI_Rsend/Irsend/Bsend/Ibsend/Ssend/Issend.

generate statement: {result =} MPI_Recv(&buffer, size, mpitype, source, tag, communicator, &status);

Definition at line 380 of file mpi_conversion.c.

{
  call mpi_call = mpic_make_generic_mpi_receive_call(buffer, size, mpitype, source, tag, communicator, status, entity_undefined);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References buffer, call_to_expression(), call_to_statement, entity_to_expression(), entity_undefined, entity_undefined_p, make_assign_statement(), mpic_make_generic_mpi_receive_call(), and statement_undefined.

Referenced by mpi_recv_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

mpic_make_mpi_send()

static statement mpic_make_mpi_send ( expression  buffer, int  size, entity  mpitype, int  dest, int  tag, entity  communicator, entity  result  )

static

generate statement: {result =} MPI_Send(&buffer, size, mpitype, dest, tag, communicator);

Definition at line 329 of file mpi_conversion.c.

{
  call mpi_call = mpic_make_generic_mpi_send_call(buffer, size, mpitype, dest, tag, communicator, entity_undefined, mpi_communication_default_mode);
  statement mpi_st = statement_undefined;
  if (entity_undefined_p(result)) {
    mpi_st = call_to_statement(mpi_call);
  }
  else {
    mpi_st = make_assign_statement(entity_to_expression(result), call_to_expression(mpi_call));
  }
  return mpi_st;
}

References buffer, call_to_expression(), call_to_statement, entity_to_expression(), entity_undefined, entity_undefined_p, make_assign_statement(), mpi_communication_default_mode, mpic_make_generic_mpi_send_call(), and statement_undefined.

Referenced by mpi_send_ctx().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_sender_entity_by_receiver_entity_in_reference()

static void replace_sender_entity_by_receiver_entity_in_reference ( reference  ref, int *  receiv_cluster  )

static

Definition at line 1055 of file mpi_conversion.c.

                                                                                                      {
  pips_debug(8, "begin\n");
  entity ent = reference_variable(ref);
  const char * prefix = get_string_property((const char * ) MPI_GENERATION_PREFIX);
  const char * ent_name = entity_user_name(ent);
  if (same_stringn_p(prefix, ent_name, strlen(prefix))) {
    char * prefix2 = strdup(concatenate(prefix, "_index_", NULL));
    if (!same_stringn_p(prefix2, ent_name, strlen(prefix2))) {
      // It's not an iterator variable, so need to modify to have the receiver variable
      pips_user_warning("Not implemented yet.\n"
          "Modify variable to use vriable of the cluster number %i", *receiv_cluster);
    //NOT good...
//    string cluster_id = strrchr(entity_name(ent),'_');
//    string new_name = gen_strndup0( entity_name(ent), strlen(entity_name(ent))-strlen(cluster_id)+1 );
////    string new_name = strdup(entity_name(ent));
////    string cluster_id = strrchr(new_name,'_');
////    new_name[cluster_id-new_name+1] = '\0';
//    pips_user_warning("new_name=%s\n", new_name);
//    new_name = concatenate(new_name, i2a(*receiv_cluster), NULL);
//    pips_user_warning("new_name=%s\n", new_name);
//
//    entity new_entity = gen_find_tabulated(new_name, entity_domain);
//    if (entity_undefined_p(new_entity)) {
//      pips_user_error("The entity %s doesn't exit\n", new_name);
//      return;
//    }
//
//    reference_variable(ref) = new_entity;
    }
    free(prefix2);
  }
  else {
    // TODO more com need to be add here, case of dynamic scheduling
    pips_user_warning("NOT a generated MPI variable (entity_name(ent)=%s)\n"
        //"Be sure that it's only a iterator variable\n"
        , entity_name(ent));
  }
 
  pips_debug(8, "end\n");
}

References concatenate(), entity_name, entity_user_name(), free(), get_string_property(), MPI_GENERATION_PREFIX, pips_debug, pips_user_warning, prefix, ref, reference_variable, same_stringn_p, and strdup().

Referenced by make_send_receive_conversion(), and test_working_false().

Here is the call graph for this function:

Here is the caller graph for this function:

search_copy_communication()

static bool search_copy_communication ( statement  stat, ctx_conv_t *  ctx  )

static

use as filter for gen_context_recurse check if the statement stat will be communication if so, generate the MPI_Send and MPI_Receive corresponding.

by this fact, when we leave the statement, we know if we encounter a communication in the explored AST

Parameters

stat	statement analyzed
ctx	context

Returns

always true

Definition at line 1349 of file mpi_conversion.c.

                                                                        {
  pips_debug(8, "begin\n");
  if (assignment_statement_p(stat) && is_distributed_comments(statement_comments(stat))) {
    int sender_cluster = find_sender_cluster(ctx, stat);
    int receiver_cluster = find_receiver_cluster(ctx, stat);
    statement mpi_send_st = generate_send_from_statement(ctx, stat);
    statement mpi_receive_st = generate_receive_from_statement(ctx, stat);
 
    ctx_inc_tag(ctx, sender_cluster, receiver_cluster);
 
    ctx_set_send_statement(ctx, mpi_send_st);
    ctx_set_receive_statement(ctx, mpi_receive_st, receiver_cluster);
    //TODO remplacer la copi par le send dans le rewrite si meme if  --> Done
    //TODO modifier les flow pour le receive dans le rewrite si statement est control flow
    //TODO add declaration pour les receive si statement sequence
  }
 
  pips_debug(8, "end\n");
  return true;
}

References assignment_statement_p(), ctx_inc_tag(), ctx_set_receive_statement(), ctx_set_send_statement(), find_receiver_cluster(), find_sender_cluster(), generate_receive_from_statement(), generate_send_from_statement(), is_distributed_comments(), pips_debug, and statement_comments.

Referenced by make_mpi_conversion(), sequence_working_false(), and test_working_false().

Here is the call graph for this function:

Here is the caller graph for this function:

sequence_working_false()

static bool sequence_working_false ( sequence  seq, ctx_conv_t *  ctx  )

static

This function update the receive statements for a sequential statement NB : This function can be put in search_copy_communication; in this case search_copy_communication can return true and false And have to treat the declaration here instead of in make_send_receive_conversion.

Parameters

seq	sequence to treat
ctx	context

Returns

always false, we make another gen_recurse in this function

en_null

en_null

Definition at line 1114 of file mpi_conversion.c.

                                                                   {
  pips_debug(8, "begin\n");
  list stats = sequence_statements(seq);
 
  int nbr_cluster = ctx->nbr_cluster;
 
  // st[cluster_num] will correspond to a sequence of MPI_recv that will update
  //   the receive statements to add
  statement st[nbr_cluster];
  for (int i = 0; i < nbr_cluster; ++i) {
    if (i!=ctx->current_cluster) {
      st[i] = make_empty_block_statement();
//      st[i] = ctx_new_body_cluster(ctx, i);
    }
  }
 
  FOREACH(STATEMENT, s, stats) {
    //TODO ...
 
    for (int i = 0; i < nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        pips_assert("receiv_statement must be undefined when we enter this function\n",
            statement_undefined_p(ctx_get_receive_statement(*ctx, i)));
      }
//      else {
//        pips_assert("\n", statement_undefined_p(ctx_get_send_statement(ctx)));
//      }
    }
 
    gen_context_multi_recurse(s, ctx
//        gen_context_recurse(s, ctx
        , statement_domain, search_copy_communication, make_send_receive_conversion
        , sequence_domain, sequence_working_false, gen_core /*gen_null*/
        , test_domain, test_working_false, gen_core /*gen_null*/
//            , loop_domain, gen_true, gen_true
//            , whileloop_domain, gen_true, gen_true
//            , forloop_domain, gen_true, gen_true
//            //, call_domain, gen_true, gen_true             // to detect copy for communication statement done in statement_domaine case
//            //, multitest_domain, gen_true, gen_true        // don't exist in PIPS yet
//            //, unstructured_domain, gen_true, gen_true     // never happens? bug case?
//            //, expression_domain, gen_true, gen_true
        , NULL
        );
 
    // between each statement of the sequence,
    // if a receive statement is present, then it is memorize in st and we reset the receive statement for the next statement to analyze
    for (int i = 0; i < nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        statement receive_statement = ctx_get_receive_statement(*ctx, i);
        if (!statement_undefined_p(receive_statement)) {
          insert_statement(st[i], receive_statement, false);
          ctx_set_receive_statement(ctx, statement_undefined, i);
        }
      }
    }
  }
 
  // At the end of the sequence,
  // the receive statement is modified to be to the st that correspond to all the receive statements that mus be done by the sequence
  for (int i = 0; i < nbr_cluster; ++i) {
    if (i!=ctx->current_cluster) {
      if (!empty_statement_or_continue_p(st[i])) {
        ctx_set_receive_statement(ctx, st[i], i);
//        ctx_set_body_statement_to_add(ctx, st[i], i);
      }
      else {
        free(st[i]);
      }
//      ctx_update_receive_statement_from_body_statement(ctx, i);
//      ctx_update_body_cluster(ctx, i);
    }
  }
 
  pips_debug(8, "end\n");
  return false;
}

References ctx_get_receive_statement(), ctx_set_receive_statement(), ctx_conv::current_cluster, empty_statement_or_continue_p(), FOREACH, free(), gen_context_multi_recurse(), gen_core(), insert_statement(), make_empty_block_statement(), make_send_receive_conversion(), ctx_conv::nbr_cluster, pips_assert, pips_debug, search_copy_communication(), sequence_domain, sequence_statements, STATEMENT, statement_domain, statement_undefined, statement_undefined_p, test_domain, and test_working_false().

Referenced by make_mpi_conversion(), and test_working_false().

Here is the call graph for this function:

Here is the caller graph for this function:

test_working_false()

static bool test_working_false ( test  t, ctx_conv_t *  ctx  )

static

This function update the receive statements for a test statement NB : This function can be put in search_copy_communication; in this case search_copy_communication can return true and false.

Parameters

t	test to treat
ctx	context

Returns

always false, we make another gen_recurse

en_null

en_null

en_null

en_null

Definition at line 1200 of file mpi_conversion.c.

                                                         {
  pips_debug(8, "begin\n");
 
  int nbr_cluster = ctx->nbr_cluster;
  statement st[nbr_cluster];
  statement st_true[nbr_cluster];
  statement st_false[nbr_cluster];
  for (int i = 0; i < nbr_cluster; ++i) {
    if (i!=ctx->current_cluster) {
//      st[i] = make_empty_block_statement();
      st[i] = statement_undefined;
      st_true[i] = statement_undefined;
      st_false[i] = statement_undefined;
      //      st[i] = ctx_new_body_cluster(ctx, i);
    }
  }
 
  expression cond = test_condition(t);
  statement ttrue = test_true(t);
  statement tfalse = test_false(t);
 
  //  //TODO analyze dynamic
  //  if (cond!=entier) {
  //    for (int i = 0; i < ctx->nbr_cluster; ++i) {
  //        if (i!=ctx->current_cluster) {
  //
  //        }
  //        else {
  //          //TODO modify AST
  //        }
  //    }
  //  }
 
  //true case
  if (!statement_undefined_p(ttrue)) {
    for (int i = 0; i < nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        pips_assert("\n", statement_undefined_p(ctx_get_receive_statement(*ctx, i)));
      }
    }
 
    gen_context_multi_recurse(ttrue, ctx
        //        gen_context_recurse(s, ctx
        , statement_domain, search_copy_communication, make_send_receive_conversion
        , sequence_domain, sequence_working_false, gen_core /*gen_null*/
        , test_domain, test_working_false, gen_core /*gen_null*/
        //            , loop_domain, gen_true, gen_true
        //            , whileloop_domain, gen_true, gen_true
        //            , forloop_domain, gen_true, gen_true
        //            //, call_domain, gen_true, gen_true             // to detect copy for communication statement done in statement_domaine case
        //            //, multitest_domain, gen_true, gen_true        // don't exist in PIPS yet
        //            //, unstructured_domain, gen_true, gen_true     // never happens? bug case?
        //            //, expression_domain, gen_true, gen_true
        , NULL
    );
 
    //Memorize the result of the true case
    for (int i = 0; i < ctx->nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        st_true[i] = ctx_get_receive_statement(*ctx, i);
        ctx_set_receive_statement(ctx, statement_undefined, i);
      }
    }
  }
 
  //false case
  if (!statement_undefined_p(tfalse)) {
    for (int i = 0; i < nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        pips_assert("\n", statement_undefined_p(ctx_get_receive_statement(*ctx, i)));
      }
    }
 
    gen_context_multi_recurse(tfalse, ctx
        //        gen_context_recurse(s, ctx
        , statement_domain, search_copy_communication, make_send_receive_conversion
        , sequence_domain, sequence_working_false, gen_core /*gen_null*/
        , test_domain, test_working_false, gen_core /*gen_null*/
        //            , loop_domain, gen_true, gen_true
        //            , whileloop_domain, gen_true, gen_true
        //            , forloop_domain, gen_true, gen_true
        //            //, call_domain, gen_true, gen_true             // to detect copy for communication statement done in statement_domaine case
        //            //, multitest_domain, gen_true, gen_true        // don't exist in PIPS yet
        //            //, unstructured_domain, gen_true, gen_true     // never happens? bug case?
        //            //, expression_domain, gen_true, gen_true
        , NULL
    );
 
    //Memorize the result of the false case
    for (int i = 0; i < ctx->nbr_cluster; ++i) {
      if (i!=ctx->current_cluster) {
        st_false[i] = ctx_get_receive_statement(*ctx, i);
        ctx_set_receive_statement(ctx, statement_undefined, i);
      }
    }
  }
 
  for (int i = 0; i < ctx->nbr_cluster; ++i) {
    //    bool need_more_com = false;     //TODO: Not implemented yet
    expression ncond = copy_expression(cond);
    if (!integer_constant_expression_p(ncond)) {
      gen_context_recurse(ncond, &i, reference_domain, gen_true2, replace_sender_entity_by_receiver_entity_in_reference);
    }
 
    if (i!=ctx->current_cluster) {
      if (!statement_undefined_p(st_true[i]) || !statement_undefined_p(st_false[i])) {
        //Generate if statement considering whether true or false case make communication
        if (statement_undefined_p(st_false[i])) {
          //Generate "if (ncond) st_true"
          st[i] = make_test_statement(
              ncond,
              st_true[i],
              make_empty_block_statement());
        }
        else if (statement_undefined_p(st_true[i])) {
          //Generate "if (!ncond) st_false"
          st[i] = make_test_statement(
              not_expression(ncond),
              //unary_intrinsic_expression(C_NOT_OPERATOR_NAME, ncond),
              st_false[i],
              make_empty_block_statement());
        }
        else {
          //Generate "if (ncond) st_true else st_false"
          st[i] = make_test_statement(
              ncond,
              st_true[i],
              st_false[i]);
        }
 
          ctx_set_receive_statement(ctx, st[i], i);
//          ctx_set_body_statement_to_add(ctx, st[i], i);
      }
    }
  }
 
  pips_debug(8, "end\n");
  return false;
}

References copy_expression(), ctx_get_receive_statement(), ctx_set_receive_statement(), ctx_conv::current_cluster, gen_context_multi_recurse(), gen_context_recurse, gen_core(), gen_true2(), integer_constant_expression_p(), make_empty_block_statement(), make_send_receive_conversion(), make_test_statement(), ctx_conv::nbr_cluster, not_expression, pips_assert, pips_debug, reference_domain, replace_sender_entity_by_receiver_entity_in_reference(), search_copy_communication(), sequence_domain, sequence_working_false(), statement_domain, statement_undefined, statement_undefined_p, test_condition, test_domain, test_false, and test_true.

Referenced by make_mpi_conversion(), and sequence_working_false().

Here is the call graph for this function:

Here is the caller graph for this function: