intercomm.h

Go to the documentation of this file.

#ifndef INTERCOMM_H
#define INTERCOMM_H

#include "ezxml/ezxml.h"
/*#include "ic_config.h"*/

#define IC_BDECOMP 1
#define IC_TTABLE 2

/* Built-in types */

typedef struct {
  int nbNode;
  char* name;
  int* tid;
  int myPos;
  char* joined;
} IC_Program;

struct leaf_node;

typedef struct decomp_TREE {
  int nDims;
  int num_of_partitions;
  struct decomp_TREE* children;
  int* keys;
  struct leaf_node* block_info;
} IC_Tree;

typedef struct {
  int type;
  void* spec;
} IC_Desc;

typedef enum { R_Enum, R_HPF } T_RegionType;
typedef enum { R_replicated, R_distributed, R_local } T_RegionDistribution;
typedef enum { Mem_Copy, Mem_Pointer } T_MemOp;


typedef struct {
  T_RegionType type;
  T_RegionDistribution distribution;
  T_MemOp mem_type;
  int size;
} IC_Region;

typedef struct OneSched_ {
  struct OneSched_ *next;
  int offset;
  int size;
} OneSched_s;

typedef struct {
  int nproc;
  int *size;
  OneSched_s **sched;
  OneSched_s **last;
} IC_Sched;


typedef struct IC_XJDComp_node {
  char* id;
  char* name;
  int ntask;
  int arrayorder;

  IC_Program* comp;
  struct IC_XJDComp_node* next;
} IC_XJDComponent;

typedef struct IC_XJDRgn_node{
    char* myname;
    char* my_region_name;
    IC_Program* me;

    char* partnername;
    char* partner_region_name;
    IC_Program* partner;

    IC_Region** region;
    int   rgn_size;
    char* commtype; /* MxN , 1xN, or Nx1  */
    char* type;  /* data types supported by InterComm */
    int   tag;
    int   usetype; /* used for export or import */
    void* local_data;

    IC_Desc*  rgn_desc;
    IC_Sched* sched;

    struct IC_XJDRgn_node* next;
} IC_XJDRegion;        


typedef struct {
  char* version;

  IC_XJDComponent* cHeader; /* component header */
  IC_XJDComponent* cTail;
  IC_XJDRegion*    rHeader; /* region list header */
  IC_XJDRegion*    rTail;
  ezxml_t          xmlRoot;  
  
  /* Pointer to the data structures used for API implementing
     loosely-coupled message transfer */
    void* meou;
} IC_XJD;


/*
  An InterComm region handle. Contains the information for data transfer. 
typedef struct {
    IC_XJDRegion* rgn;
    
    tHandle thandle;  // for SML
     double timing;    // for SML
     iHandle ihandle;  // for SML
} IC_RegionHandle;
 */

enum {
  IC_ROW_MAJOR = 0, 
  IC_COLUMN_MAJOR = 1, 
};


IC_Program* IC_Init(char* name, int tasks, int rank);

IC_Program* IC_Wait(char* name, int tasks);

int IC_Sync(IC_Program* myprog, IC_Program* prog);

IC_Desc* IC_Create_bdecomp_desc(int ndims, int* blocks, int* tasks, int count, int arrayOrder);

IC_Desc* IC_Create_ttable_desc(int* globals, int* locals, int* tasks, int count);

IC_Tree* IC_Create_bdecomp_tree();

void IC_Section(IC_Tree* root, int dim, int count, int* indices);

void IC_Partition(IC_Tree* root, int dim, int* block, int count, int* indices);

IC_Desc* IC_Verify_bdecomp_tree(IC_Tree* root, int ndims, int* size, int* tasks, int count, int arrayOrder);

IC_Region* IC_Create_block_region(int ndims, int* lower, int* upper, int* stride);

IC_Region* IC_Create_enum_region(int* indices, int count);


IC_Sched* IC_Compute_schedule(IC_Program* myprog, IC_Program* prog, IC_Desc* desc, 
                              IC_Region** region_set, int set_size);

/* These TYPE functions are added as placeholders for Doxygen */
#define TYPE void

int IC_Send_TYPE(IC_Program* to, IC_Sched* sched, TYPE* data, int tag);

int IC_Send_char(IC_Program* to, IC_Sched* sched, char* data, int tag);
int IC_Send_short(IC_Program* to, IC_Sched* sched, short* data, int tag);
int IC_Send_int(IC_Program* to, IC_Sched* sched, int* data, int tag);
int IC_Send_long(IC_Program* to, IC_Sched* sched, long* data, int tag);
int IC_Send_float(IC_Program* to, IC_Sched* sched, float* data, int tag);
int IC_Send_double(IC_Program* to, IC_Sched* sched, double* data, int tag);

int IC_Recv_TYPE(IC_Program* from, IC_Sched* sched, TYPE* data, int tag);

int IC_Recv_char(IC_Program* from, IC_Sched* sched, char* data, int tag);
int IC_Recv_short(IC_Program* from, IC_Sched* sched, short* data, int tag);
int IC_Recv_int(IC_Program* from, IC_Sched* sched, int* data, int tag);
int IC_Recv_float(IC_Program* from, IC_Sched* sched, float* data, int tag);
int IC_Recv_double(IC_Program* from, IC_Sched* sched, double* data, int tag);

void IC_Free_sched(IC_Sched* sched);

void IC_Free_region(IC_Region* region);

void IC_Free_desc(IC_Desc* desc);

void IC_Free_program(IC_Program* prog);

void IC_Quit(IC_Program* myprog);

void IC_Print_error(char* msg);


IC_XJD* IC_Initialize(char* pName, int rank, char* xjdname, int* status);


void IC_Register_region(IC_XJD* xjd, IC_Region** rgnset, int set_size, char* set_name, IC_Desc* desc, void* local_data, int* status);


void IC_Commit_region(IC_XJD* xjd, int* status);


int IC_Export(IC_XJD* xjd, char* rgnset_name);

    
int IC_Import(IC_XJD* xjd, char* rgnset_name);


int IC_Bcast_local_TYPE(IC_Program* to, TYPE* data, int nelems, int tag);

int IC_Bcast_local_char(IC_Program* to, char* data, int nelems, int tag);
int IC_Bcast_local_short(IC_Program* to, short* data, int nelems, int tag);
int IC_Bcast_local_int(IC_Program* to, int* data, int nelems, int tag);
int IC_Bcast_local_float(IC_Program* to, float* data, int nelems, int tag);
int IC_Bcast_local_double(IC_Program* to, double* data, int nelems, int tag);


int IC_Recv_local_TYPE(IC_Program* from, TYPE* data, int nelems, int tag);

int IC_Recv_local_char(IC_Program* from, char* data, int nelems, int tag);
int IC_Recv_local_short(IC_Program* from, short* data, int nelems, int tag);
int IC_Recv_local_int(IC_Program* from, int* data, int nelems, int tag);
int IC_Recv_local_float(IC_Program* from, float* data, int nelems, int tag);
int IC_Recv_local_double(IC_Program* from, double* data, int nelems, int tag);



int IC_Bcast_local(IC_XJD* xjd, char* rgnset_name, void* data, int nelems);


int IC_Recv_local(IC_XJD* xjd, char* rgnset_name, void* data, int nelems);


void IC_Finalize(IC_XJD* xjd, int* icsts);


#endif /* INTERCOMM_H */

---