VMPI_stream.h

Go to the documentation of this file.

/* ############################ MALP License ############################## */
/* # Fri Jan 18 14:00:00 CET 2013                                         # */
/* # Copyright or (C) or Copr. Commissariat a l'Energie Atomique          # */
/* #                                                                      # */
/* # This software is governed by the CeCILL-C license under French law   # */
/* # and abiding by the rules of distribution of free software.  You can  # */
/* # use, modify and/ or redistribute the software under the terms of     # */
/* # the CeCILL-C license as circulated by CEA, CNRS and INRIA at the     # */
/* # following URL http://www.cecill.info.                                # */
/* #                                                                      # */
/* # The fact that you are presently reading this means that you have     # */
/* # had knowledge of the CeCILL-C license and that you accept its        # */
/* # terms.                                                               # */
/* #                                                                      # */
/* # Authors:                                                             # */
/* #   - BESNARD Jean-Baptiste jean-baptiste.besnard@cea.fr               # */
/* #                                                                      # */
/* ######################################################################## */



#ifndef VMPI_STREAMS
#define VMPI_STREAMS

#include <mpi.h>

#ifdef __cplusplus
extern "C" {
#endif

#include <stdlib.h>
#include <VMPI.h>
#include <Spinlock.h>

typedef enum
{
        VMPI_STREAM_BALANCE_NONE,                       
        VMPI_STREAM_BALANCE_RANDOM,                     
        VMPI_STREAM_BALANCE_ROUND_ROBIN         
}VMPI_Stream_load_balance;

typedef enum
{
        VMPI_STREAM_R,  
        VMPI_STREAM_W,  
        VMPI_STREAM_RW  
}VMPI_Stream_mode;


typedef enum
{
        VMPI_STREAM_BLOCK,              
        VMPI_STREAM_NONBLOCK    
}VMPI_Stream_blocking;

struct _VMPI_Stream
{
        int target;             
        int remote_tag; 
        int local_tag;  
        int state;              
};

#define VMPI_STREAM_MAX_ASYNC 10

typedef struct
{
        struct _VMPI_Stream *in;                                        
        int current_in;                                                         
        int in_count;                                                           
        struct _VMPI_Stream *out;                                       
        int current_out;                                                        
        int out_count;                                                          
        size_t block_size;                                                      
        char **r_tmp_buffers;                                           
        int *r_current_buff;                                            
        MPI_Request *r_req;                                                     
        MPI_Status *r_stat;                                                     
        int r_req_count;                                                        
        char *w_tmp_buffers[VMPI_STREAM_MAX_ASYNC];     
        MPI_Request w_req[VMPI_STREAM_MAX_ASYNC];       
        MPI_Status w_stat[VMPI_STREAM_MAX_ASYNC];       
        int w_req_count;                                                        
        VMPI_Stream_load_balance lb;                            
    MALP_Spinlock lock;                         
}VMPI_Stream;

int VMPI_Stream_init( VMPI_Stream *st, size_t block_size, VMPI_Stream_load_balance lb);

int VMPI_Stream_open( VMPI_Stream *st, int dest, char *mode );

int VMPI_Stream_open_map( VMPI_Stream *st, VMPI_Map *map, char *mode );

int VMPI_Stream_close( VMPI_Stream * st );


int VMPI_Stream_join(VMPI_Stream * dest, VMPI_Stream * src);

int VMPI_Stream_read( VMPI_Stream * st, char *buff, unsigned int block_count, VMPI_Stream_blocking block );

int VMPI_Stream_write( VMPI_Stream * st, char *buff, unsigned int block_count );

int VMPI_Stream_test_read( VMPI_Stream * st );

int VMPI_Stream_test_write( VMPI_Stream * st );

static inline int VMPI_Stream_read_count( VMPI_Stream * st )
{
        return st->in_count;
}

static inline int VMPI_Stream_write_count( VMPI_Stream * st )
{
        return st->out_count;
}

#ifdef __cplusplus
}
#endif

#endif /* VMPI_STREAMS */