/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */

/*

 *  (C) 2001 by Argonne National Laboratory.

 *      See COPYRIGHT in top-level directory.

 */

#ifndef RLOG_H_INCLUDED

#define RLOG_H_INCLUDED

#include <stdio.h>

#if defined(__cplusplus)

extern "C" {

#endif

/* definitions */

#ifndef RLOG_BOOL

#define RLOG_BOOL int

#endif

#define RLOG_BUFFSIZE           (8*1024*1024)

#define RLOG_MAX_RECORD_SIZE     1024

#define RLOG_COLOR_LENGTH       (3 * sizeof(double))

#define RLOG_DESCRIPTION_LENGTH (5 * sizeof(double))

#define RLOG_MAX_DOUBLE         (1e100)

#define RLOG_MIN_DOUBLE         (-1e100)

#define RLOG_SENDER   1

#define RLOG_RECEIVER 0

#define RLOG_FIRST_EVENT_ID 1500

#define RLOG_ARROW_EVENT_ID 1499

/* structures */

    typedef enum RLOG_RECORD_TYPE {

        RLOG_INVALID_TYPE = 0,

        RLOG_ENDLOG_TYPE,

        RLOG_EVENT_TYPE,

        RLOG_ARROW_TYPE,

        RLOG_IARROW_TYPE,

        RLOG_STATE_TYPE,

        RLOG_COMM_TYPE

    } RLOG_RECORD_TYPE;

    typedef struct RLOG_HEADER {

        RLOG_RECORD_TYPE type;

        int length;

    } RLOG_HEADER;

    typedef struct RLOG_STATE {

        int event;

        int pad;

        char color[RLOG_COLOR_LENGTH];

        char description[RLOG_DESCRIPTION_LENGTH];

    } RLOG_STATE;

/* FIXME: RLOG should use the generic (and lighter weight) timestamp type,

   not a double, for recording the timestamp bits.  This is an unnecessary

   extra overhead that makes RLOG less appropriate for fine-grain logging */

    typedef struct RLOG_EVENT {

        int rank;

        int event;

        int pad;

        int recursion;

        double start_time;

        double end_time;

    } RLOG_EVENT;

#define RLOG_ARROW_LEFT  1

#define RLOG_ARROW_RIGHT 0

    typedef struct RLOG_ARROW {

        int src;

        int dest;

        int tag;

        int length;

        int leftright;

        int pad;

        double start_time;

        double end_time;

    } RLOG_ARROW;

    typedef struct RLOG_IARROW {

        int sendrecv;

        int rank;

        int remote;

        int tag;

        int length;

        int pad;

        double timestamp;

    } RLOG_IARROW;

    typedef struct RLOG_COMM {

        int newcomm;

        int rank;

    } RLOG_COMM;

#define RLOG_HEADER_SECTION         0

#define RLOG_STATE_SECTION          1

#define RLOG_ARROW_SECTION          2

#define RLOG_EVENT_SECTION          3

    typedef struct RLOG_FILE_HEADER {

        int nMinRank, nMaxRank;

    } RLOG_FILE_HEADER;

    typedef struct IRLOG_IOStruct {

        FILE *f;

        RLOG_HEADER header;

        union RLOG_DATA {

            RLOG_STATE state;

            RLOG_EVENT event;

            RLOG_IARROW iarrow;

            RLOG_COMM comm;

        } record;

        char *pCurHeader;

        char *pNextHeader;

        char *pEnd;

        char buffer[RLOG_BUFFSIZE];

    } IRLOG_IOStruct;

    typedef struct RLOG_IOStruct {

        FILE *f;

        RLOG_FILE_HEADER header;

        int nNumStates, nCurState;

        long nStateOffset;

        int nNumArrows, nCurArrow;

        long nArrowOffset;

        int nNumRanks;

        int *pRank;

        int *pNumEventRecursions;

        int **ppNumEvents, **ppCurEvent;

        int **ppCurGlobalEvent;

        RLOG_EVENT **gppCurEvent, **gppPrevEvent, gCurEvent;

        int gnCurRank, gnCurLevel, gnCurEvent;

        long **ppEventOffset;

    } RLOG_IOStruct;

    typedef struct RLOG_Struct {

        int bLogging;

        int nCurEventId;

        char pszFileName[256];

        int nRank;

        int nSize;

        int nRecursion;

        double dFirstTimestamp;

        RLOG_HEADER DiskHeader;

        RLOG_EVENT DiskEvent;

        IRLOG_IOStruct *pOutput;

    } RLOG_Struct;

/* function prototypes */

/* logging functions */

    RLOG_Struct *RLOG_InitLog(int rank, int size);

    int RLOG_FinishLog(RLOG_Struct * pRLOG);

/*void RLOG_LogEvent(RLOG_Struct *pRLOG, int event, double starttime, double endtime, int recursion);*/

    void RLOG_LogSend(RLOG_Struct * pRLOG, int dest, int tag, int size);

    void RLOG_LogRecv(RLOG_Struct * pRLOG, int src, int tag, int size);

    void RLOG_LogCommID(RLOG_Struct * pRLOG, int id);

    void RLOG_DescribeState(RLOG_Struct * pRLOG, int state, char *name, char *color);

    void RLOG_EnableLogging(RLOG_Struct * pRLOG);

    void RLOG_DisableLogging(RLOG_Struct * pRLOG);

    int RLOG_GetNextEventID(RLOG_Struct * pRLOG);

    void RLOG_SaveFirstTimestamp(RLOG_Struct * pRLOG);

/* irlog utility functions */

    IRLOG_IOStruct *IRLOG_CreateInputStruct(const char *filename);

    IRLOG_IOStruct *IRLOG_CreateOutputStruct(const char *filename);

    int IRLOG_GetNextRecord(IRLOG_IOStruct * pInput);

    int IRLOG_WriteRecord(RLOG_HEADER * pRecord, IRLOG_IOStruct * pOutput);

    int IRLOG_CloseInputStruct(IRLOG_IOStruct ** ppInput);

    int IRLOG_CloseOutputStruct(IRLOG_IOStruct ** ppOutput);

/* rlog utility functions */

    RLOG_IOStruct *RLOG_CreateInputStruct(const char *filename);

    int RLOG_CloseInputStruct(RLOG_IOStruct ** ppInput);

    int RLOG_GetFileHeader(RLOG_IOStruct * pInput, RLOG_FILE_HEADER * pHeader);

    int RLOG_GetNumStates(RLOG_IOStruct * pInput);

    int RLOG_GetState(RLOG_IOStruct * pInput, int i, RLOG_STATE * pState);

    int RLOG_ResetStateIter(RLOG_IOStruct * pInput);

    int RLOG_GetNextState(RLOG_IOStruct * pInput, RLOG_STATE * pState);

    int RLOG_GetNumArrows(RLOG_IOStruct * pInput);

    int RLOG_GetArrow(RLOG_IOStruct * pInput, int i, RLOG_ARROW * pArrow);

    int RLOG_ResetArrowIter(RLOG_IOStruct * pInput);

    int RLOG_GetNextArrow(RLOG_IOStruct * pInput, RLOG_ARROW * pArrow);

    int RLOG_GetRankRange(RLOG_IOStruct * pInput, int *pMin, int *pMax);

    int RLOG_GetNumEventRecursions(RLOG_IOStruct * pInput, int rank);

    int RLOG_GetNumEvents(RLOG_IOStruct * pInput, int rank, int recursion_level);

    int RLOG_GetEvent(RLOG_IOStruct * pInput, int rank, int recursion_level, int index,

                      RLOG_EVENT * pEvent);

    int RLOG_ResetEventIter(RLOG_IOStruct * pInput, int rank, int recursion_level);

    int RLOG_GetNextEvent(RLOG_IOStruct * pInput, int rank, int recursion_level,

                          RLOG_EVENT * pEvent);

    int RLOG_FindEventBeforeTimestamp(RLOG_IOStruct * pInput, int rank, int recursion_level,

                                      double timestamp, RLOG_EVENT * pEvent, int *pIndex);

    int RLOG_FindAnyEventBeforeTimestamp(RLOG_IOStruct * pInput, int rank, double timestamp,

                                         RLOG_EVENT * pEvent);

    int RLOG_ResetGlobalIter(RLOG_IOStruct * pInput);

    int RLOG_GetNextGlobalEvent(RLOG_IOStruct * pInput, RLOG_EVENT * pEvent);

    int RLOG_GetPreviousGlobalEvent(RLOG_IOStruct * pInput, RLOG_EVENT * pEvent);

    int RLOG_GetCurrentGlobalEvent(RLOG_IOStruct * pInput, RLOG_EVENT * pEvent);

    int RLOG_FindGlobalEventBeforeTimestamp(RLOG_IOStruct * pInput, double timestamp,

                                            RLOG_EVENT * pEvent);

    int RLOG_FindArrowBeforeTimestamp(RLOG_IOStruct * pInput, double timestamp, RLOG_ARROW * pArrow,

                                      int *pIndex);

    int RLOG_HitTest(RLOG_IOStruct * pInput, int rank, int level, double timestamp,

                     RLOG_EVENT * pEvent);

    int RLOG_ModifyEvents(const char *log_filename, double *pOffsets, int num_offsets);

/* debugging functions */

    int RLOG_PrintGlobalState(RLOG_IOStruct * pInput);

/* macros */

#define RLOG_HEADER_CAST() ((RLOG_HEADER*)pRLOG->pOutput->pCurHeader)

#define RLOG_EVENT_CAST()  ((RLOG_EVENT*)((char*)pRLOG->pOutput->pCurHeader + sizeof(RLOG_HEADER)))

#define RLOG_LogEvent(pRLOG, event_param, starttime, endtime, recursion_param) \

    if (pRLOG->bLogging)                                                \

    {                                                                   \

        if (pRLOG->pOutput->pCurHeader + sizeof(RLOG_HEADER) + sizeof(RLOG_EVENT) > pRLOG->pOutput->pEnd) \

        {                                                               \

            WriteCurrentDataAndLogEvent(pRLOG, event_param, starttime, endtime, recursion_param); \

        }                                                               \

        else                                                            \

        {                                                               \

            RLOG_HEADER_CAST()->type = RLOG_EVENT_TYPE;                 \

            RLOG_HEADER_CAST()->length = sizeof(RLOG_HEADER) + sizeof(RLOG_EVENT); \

            RLOG_EVENT_CAST()->rank = pRLOG->nRank;                     \

            RLOG_EVENT_CAST()->end_time = endtime - pRLOG->dFirstTimestamp; \

            RLOG_EVENT_CAST()->start_time = starttime - pRLOG->dFirstTimestamp; \

            RLOG_EVENT_CAST()->event = event_param;                     \

            RLOG_EVENT_CAST()->recursion = recursion_param;             \

            /* advance the current position pointer */                  \

            pRLOG->pOutput->pCurHeader += sizeof(RLOG_HEADER) + sizeof(RLOG_EVENT); \

        }                                                               \

    }

    void WriteCurrentDataAndLogEvent(RLOG_Struct * pRLOG, int event, double starttime,

                                     double endtime, int recursion);

#if defined(__cplusplus)

}

#endif

#endif                          /* RLOG_H_INCLUDED */