fti.h

Go to the documentation of this file.

#ifndef _FTI_H
#define _FTI_H

#include <mpi.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>

/*---------------------------------------------------------------------------
  Defines
  ---------------------------------------------------------------------------*/

#define RED   "\x1B[31m"

#define ORG   "\x1B[38;5;202m"

#define GRN   "\x1B[32m"

#define BLU   "\x1B[34m"

#define RESET "\x1B[0m"

#define FTI_BUFS 256

#define FTI_WORD 16

#define FTI_DONE 1

#define FTI_SCES 0

#define FTI_NSCS -1

#define FTI_NREC -2

#define FTI_EROR 4

#define FTI_WARN 3

#define FTI_IDCP 5

#define FTI_INFO 2

#define FTI_DBUG 1

#define FTI_BASE 990

#define FTI_CKTW 991

#define FTI_XORW 992

#define FTI_RSEW 993

#define FTI_PFSW 994

#define FTI_ENDW 995

#define FTI_REJW 996

#define FTI_IO_POSIX 1001

#define FTI_IO_MPI 1002

#define FTI_IO_FTIFF 1003

#define FTI_SI_FAIL 0x4

#define FTI_SI_SCES 0x3

#define FTI_SI_ACTV 0x2

#define FTI_SI_PEND 0x1

#define FTI_SI_NINI 0x0

#define FTI_SI_MAX_NUM (512L*1024L) 

#define MD5_DIGEST_LENGTH 16

#define MD5_DIGEST_STRING_LENGTH 33

#ifdef ENABLE_SIONLIB // --> If SIONlib is installed

#define FTI_IO_SIONLIB 1004
#endif

#define FTI_IO_HDF5 1005
#ifdef ENABLE_HDF5 // --> If HDF5 is installed
    #include "hdf5.h"
#endif

#define FTI_DCP_MODE_OFFSET 2000
#define FTI_DCP_MODE_MD5 2001
#define FTI_DCP_MODE_CRC32 2002

#ifdef __cplusplus
extern "C" {
#endif

    /*---------------------------------------------------------------------------
      FTI-FF types
      ---------------------------------------------------------------------------*/
    
    typedef enum {
        FTI_L1 = 1,
        FTI_L2,
        FTI_L3,
        FTI_L4,
        FTI_L1_DCP,
        FTI_L2_DCP,
        FTI_L3_DCP,
        FTI_L4_DCP,
        FTI_MIN_LEVEL_ID = FTI_L1,
        FTI_MAX_LEVEL_ID = FTI_L4_DCP
    } FTIT_level;

    typedef uintptr_t           FTI_ADDRVAL;        
    typedef void*               FTI_ADDRPTR;        
    typedef struct FTIFF_metaInfo {
        char checksum[MD5_DIGEST_STRING_LENGTH]; 
        unsigned char myHash[MD5_DIGEST_LENGTH]; 
        long ckptSize;  
        long fs;        
        long maxFs;     
        long ptFs;      
        long timestamp; 
        long dcpSize;   
        long dataSize;  
    } FTIFF_metaInfo;

    typedef struct              FTIT_DataDiffHash
    {
        unsigned char*          md5hash;    
        unsigned short          blockSize;  
        uint32_t                bit32hash;  
        bool                    dirty;      
        bool                    isValid;    
    }FTIT_DataDiffHash;

    typedef struct FTIFF_dbvar {
        int id;             
        int idx;            
        int containerid;    
        bool hascontent;    
        bool hasCkpt;       
        uintptr_t dptr;     
        uintptr_t fptr;     
        long chunksize;     
        long containersize; 
        unsigned char hash[MD5_DIGEST_LENGTH];  
        unsigned char myhash[MD5_DIGEST_LENGTH];  
        bool update;        
        long nbHashes;      
        FTIT_DataDiffHash* dataDiffHash; 
        char *cptr;         
    } FTIFF_dbvar;

    typedef struct FTIFF_db {
        int numvars;            
        long dbsize;            
        unsigned char myhash[MD5_DIGEST_LENGTH];  
        bool update;        
        FTIFF_dbvar *dbvars;    
        struct FTIFF_db *previous;  
        struct FTIFF_db *next;      
    } FTIFF_db;

    /*---------------------------------------------------------------------------
      New types
      ---------------------------------------------------------------------------*/

    typedef struct FTIT_StageInfo {
        int nbRequest;  
        void *request;  
    } FTIT_StageInfo;

    typedef union FTIT_double {
        double          value;              
        float           floatval[2];        
        int             intval[2];          
        char            byte[8];            
    } FTIT_double;

    typedef union FTIT_float {
        float           value;              
        int             intval;             
        char            byte[4];            
    } FTIT_float;

    typedef struct FTIT_complexType FTIT_complexType;

    typedef struct FTIT_H5Group FTIT_H5Group;

    typedef struct FTIT_H5Group {
        int                 id;                     
        char                name[FTI_BUFS];         
        int                 childrenNo;             
        int                 childrenID[FTI_BUFS];   
#ifdef ENABLE_HDF5
        hid_t               h5groupID;              
#endif
    } FTIT_H5Group;

    typedef struct FTIT_type {
        int                 id;                     
        int                 size;                   
        FTIT_complexType*   structure;              
        FTIT_H5Group*       h5group;                
#ifdef ENABLE_HDF5
        hid_t               h5datatype;             
#endif
    } FTIT_type;

    typedef struct FTIT_typeField {
        int                 typeID;                 
        int                 offset;                 
        int                 rank;                   
        int                 dimLength[32];          
        char                name[FTI_BUFS];         
    } FTIT_typeField;

    typedef struct FTIT_complexType {
        char                name[FTI_BUFS];         
        int                 length;                 
        FTIT_typeField      field[FTI_BUFS];        
    } FTIT_complexType;

    typedef struct FTIT_dataset {
        int             id;                 
        void            *ptr;               
        long            count;              
        FTIT_type*      type;               
        int             eleSize;            
        long            size;               
        int             rank;               
        int             dimLength[32];      
        char            name[FTI_BUFS];     
        FTIT_H5Group*   h5group;            
    } FTIT_dataset;

    typedef struct FTIT_metadata {
        int*             exists;             
        long*            maxFs;              
        long*            fs;                 
        long*            pfs;                
        char*            ckptFile;           
        char*            currentL4CkptFile;  
        int*             nbVar;              
        int*             varID;              
        long*            varSize;            
    } FTIT_metadata;

    typedef struct FTIT_execution {
        char            id[FTI_BUFS];       
        int             ckpt;               
        int             reco;               
        int             ckptLvel;           
        int             ckptIntv;           
        int             lastCkptLvel;       
        int             wasLastOffline;     
        double          iterTime;           
        double          lastIterTime;       
        double          meanIterTime;       
        double          globMeanIter;       
        double          totalIterTime;      
        unsigned int    syncIter;           
        int             syncIterMax;        
        unsigned int    minuteCnt;          
        bool            hasCkpt;            
        unsigned int    ckptCnt;            
        unsigned int    ckptIcnt;           
        unsigned int    ckptID;             
        unsigned int    ckptNext;           
        unsigned int    ckptLast;           
        long            ckptSize;           
        unsigned int    nbVar;              
        unsigned int    nbVarStored;        
        unsigned int    nbType;             
        int             nbGroup;            
        int             metaAlloc;          
        int             initSCES;           
        FTIT_metadata   meta[5];            
        FTIFF_db         *firstdb;          
        FTIFF_db         *lastdb;           
        FTIFF_metaInfo  FTIFFMeta;          
        FTIT_type**     FTI_Type;           
        FTIT_H5Group**  H5groups;           
        FTIT_StageInfo* stageInfo;          
        MPI_Comm        globalComm;         
        MPI_Comm        groupComm;          
        MPI_Comm        nodeComm;
    } FTIT_execution;

    typedef struct FTIT_configuration {
        bool            stagingEnabled;
        bool            dcpEnabled;         
        bool            keepL4Ckpt;         
        int             dcpMode;            
        int             dcpBlockSize;       
        char            cfgFile[FTI_BUFS];  
        int             saveLastCkpt;       
        int             verbosity;          
        int             blockSize;          
        int             transferSize;       
#ifdef LUSTRE
        int             stripeUnit;         
        int             stripeOffset;       
        int             stripeFactor;       
#endif
        int             ckptTag;            
        int             stageTag;           
        int             finalTag;           
        int             generalTag;         
        int             test;               
        int             l3WordSize;         
        int             ioMode;             
        char            stageDir[FTI_BUFS];
        char            localDir[FTI_BUFS]; 
        char            glbalDir[FTI_BUFS]; 
        char            metadDir[FTI_BUFS]; 
        char            lTmpDir[FTI_BUFS];  
        char            gTmpDir[FTI_BUFS];  
        char            mTmpDir[FTI_BUFS];  
    } FTIT_configuration;

    typedef struct FTIT_topology {
        int             nbProc;             
        int             nbNodes;            
        int             myRank;             
        int             splitRank;          
        int             nodeSize;           
        int             nbHeads;            
        int             nbApprocs;          
        int             groupSize;          
        int             sectorID;           
        int             nodeID;             
        int             groupID;            
        int             amIaHead;           
        int             headRank;           
        int             headRankNode;       
        int             nodeRank;           
        int             groupRank;          
        int             right;              
        int             left;               
        int             body[FTI_BUFS];     
    } FTIT_topology;


    typedef struct FTIT_checkpoint {
        char            dir[FTI_BUFS];      
        char            dcpDir[FTI_BUFS];   
        char            archDir[FTI_BUFS];  
        char            metaDir[FTI_BUFS];  
        char            dcpName[FTI_BUFS];  
        bool            isDcp;              
        bool            hasDcp;             
        bool            hasCkpt;            
        int             isInline;           
        int             ckptIntv;           
        int             ckptCnt;            
        int             ckptDcpIntv;        
        int             ckptDcpCnt;         
    } FTIT_checkpoint;

    typedef struct FTIT_injection {
        int             rank;               
        int             index;              
        int             position;           
        int             number;             
        int             frequency;          
        int             counter;            
        double          timer;              
    } FTIT_injection;

    /*---------------------------------------------------------------------------
      Global variables
      ---------------------------------------------------------------------------*/

    extern MPI_Comm FTI_COMM_WORLD;

    extern FTIT_type FTI_CHAR;
    extern FTIT_type FTI_SHRT;
    extern FTIT_type FTI_INTG;
    extern FTIT_type FTI_LONG;
    extern FTIT_type FTI_UCHR;
    extern FTIT_type FTI_USHT;
    extern FTIT_type FTI_UINT;
    extern FTIT_type FTI_ULNG;
    extern FTIT_type FTI_SFLT;
    extern FTIT_type FTI_DBLE;
    extern FTIT_type FTI_LDBE;

    /*---------------------------------------------------------------------------
      FTI public functions
      ---------------------------------------------------------------------------*/

    int FTI_Init(char *configFile, MPI_Comm globalComm);
    int FTI_Status();
    int FTI_InitType(FTIT_type* type, int size);
    int FTI_InitComplexType(FTIT_type* newType, FTIT_complexType* typeDefinition, int length,
                            size_t size, char* name, FTIT_H5Group* h5group);
    void FTI_AddSimpleField(FTIT_complexType* typeDefinition, FTIT_type* ftiType,
                                size_t offset, int id, char* name);
    void FTI_AddComplexField(FTIT_complexType* typeDefinition, FTIT_type* ftiType,
                                size_t offset, int rank, int* dimLength, int id, char* name);
    int FTI_InitGroup(FTIT_H5Group* h5group, char* name, FTIT_H5Group* parent);
    int FTI_RenameGroup(FTIT_H5Group* h5group, char* name);
    int FTI_Protect(int id, void* ptr, long count, FTIT_type type);
    int FTI_DefineDataset(int id, int rank, int* dimLength, char* name, FTIT_H5Group* h5group);
    long FTI_GetStoredSize(int id);
    void* FTI_Realloc(int id, void* ptr);
    int FTI_BitFlip(int datasetID);
    int FTI_Checkpoint(int id, int level);
    int FTI_GetStageDir( char* stageDir, int maxLen );
    int FTI_GetStageStatus( int ID );
    int FTI_SendFile( char* lpath, char *rpath );
    int FTI_Recover();
    int FTI_Snapshot();
    int FTI_Finalize();
    int FTI_RecoverVar(int id);

#ifdef __cplusplus
}
#endif

#endif /* ----- #ifndef _FTI_H  ----- */