ImageStruct.h

Go to the documentation of this file.

 
#ifndef _IMAGESTRUCT_H
#define _IMAGESTRUCT_H
 
#define IMAGESTRUCT_VERSION "1.01"
 
#define STRINGMAXLEN_IMAGE_NAME          80
#define KEYWORD_MAX_STRING  16            
#define KEYWORD_MAX_COMMENT 80            
#include <semaphore.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h> // TEST
 
#ifdef HAVE_CUDA
// CUDA runtime includes
#include <cuda_runtime_api.h>
#else
// CUDA cudaIpcMemHandle_t is a struct of 64 bytes
// This is needed for for compatibility between ImageStreamIO
// compiled with or without HAVE_CUDA precompiler flag
typedef char cudaIpcMemHandle_t[64];
#endif
 
#include "ImageStreamIOError.h"
 
#ifdef __MACH__
#include <mach/mach_time.h>
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 0
static int clock_gettime(int clk_id, struct mach_timespec *t) {
    mach_timebase_info_data_t timebase;
    mach_timebase_info(&timebase);
    uint64_t time;
    time = mach_absolute_time();
    double nseconds =
        ((double)time * (double)timebase.numer) / ((double)timebase.denom);
    double seconds =
        ((double)time * (double)timebase.numer) / ((double)timebase.denom * 1e9);
    t->tv_sec = seconds;
    t->tv_nsec = nseconds;
    return EXIT_SUCCESS;
}
#else
#include <time.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
// comment this line if data should not be packed
// packing data should be use with extreme care, so it is recommended to disable this feature
//#define DATA_PACKED
 
#define SHAREDMEMDIR    "/milk/shm"          
#define SEMAPHORE_MAXVAL    10            
#define SEMAPHORE_INITVAL    0            
#define IMAGE_NB_SEMAPHORE  10            
#define IMAGE_NB_PROCTRACE  10            
// Data types are defined as machine-independent types for portability
 
#define _DATATYPE_UINT8                                1  
#define SIZEOF_DATATYPE_UINT8                          1
 
#define _DATATYPE_INT8                                 2  
#define SIZEOF_DATATYPE_INT8                           1
 
#define _DATATYPE_UINT16                               3  
#define SIZEOF_DATATYPE_UINT16                         2
 
#define _DATATYPE_INT16                                4  
#define SIZEOF_DATATYPE_INT16                          2
 
#define _DATATYPE_UINT32                               5  
#define SIZEOF_DATATYPE_UINT32                         4
 
#define _DATATYPE_INT32                                6  
#define SIZEOF_DATATYPE_INT32                          4
 
#define _DATATYPE_UINT64                               7  
#define SIZEOF_DATATYPE_UINT64                         8
 
#define _DATATYPE_INT64                                8  
#define SIZEOF_DATATYPE_INT64                          8
 
#define _DATATYPE_HALF                                13  
#define SIZEOF_DATATYPE_HALF                           2
 
#define _DATATYPE_FLOAT                                9  
#define SIZEOF_DATATYPE_FLOAT                          4
 
#define _DATATYPE_DOUBLE                              10 
#define SIZEOF_DATATYPE_DOUBLE                         8
 
#define _DATATYPE_COMPLEX_FLOAT                       11  
#define SIZEOF_DATATYPE_COMPLEX_FLOAT                  8
 
#define _DATATYPE_COMPLEX_DOUBLE                      12  
#define SIZEOF_DATATYPE_COMPLEX_DOUBLE                16
 
#define _DATATYPE_EVENT_UI8_UI8_UI16_UI8              20
#define SIZEOF_DATATYPE_EVENT_UI8_UI8_UI16_UI8         5
 
#define Dtype                                          9   
#define CDtype                                        11   
// Type of stream
 
#define CIRCULAR_BUFFER  0x0001  
#define MATH_DATA        0x0002  
#define IMG_RECV         0x0004  
#define IMG_SENT         0x0008  
// axis0 definition
 
#define ZAXIS_UNDEF      0x00000  
#define ZAXIS_SPACIAL    0x10000  
#define ZAXIS_TEMPORAL   0x20000  
#define ZAXIS_WAVELENGTH 0x30000  
#define ZAXIS_MAPPING    0x40000  
typedef struct {
    char name[KEYWORD_MAX_STRING]; 
    char type;                     
    uint64_t : 0;                  // align array to 8-byte boundary for speed
 
    union {
        int64_t numl;
        double  numf;
        char    valstr[KEYWORD_MAX_STRING];
    } value;
 
    char comment[KEYWORD_MAX_COMMENT];
#ifdef DATA_PACKED
} __attribute__((__packed__)) IMAGE_KEYWORD;
#else
} IMAGE_KEYWORD;
#endif
 
typedef struct {
    int64_t firstlong;
    int64_t secondlong;
} TIMESPECFIXED;
 
typedef struct {
    float re;
    float im;
} complex_float;
 
typedef struct {
    double re;
    double im;
} complex_double;
 
 
 
 
typedef struct
{
    char version[32];
    char name[STRINGMAXLEN_IMAGE_NAME];
 
 
    uint8_t naxis;
 
 
    uint32_t size[3];
 
 
    uint64_t nelement;
 
 
 
    uint8_t datatype;
 
 
 
 
 
    uint64_t imagetype;              
    // relative timers using time relative to process start
 
    // double creationtime;             /**< Creation / load time of data structure (since process start)  */
    // double lastaccesstime;           /**< last time the image was accessed  (since process start)                      */
 
 
 
    // absolute timers using struct timespec
 
    struct timespec creationtime;
    struct timespec lastaccesstime;
 
    struct timespec atime;             
    struct timespec writetime;         
    pid_t creatorPID;  
    pid_t ownerPID;    
    /* May be used to purge stream(s) when a process is completed/dead */
    /* Initialized to 0 */
    /* Set to 1 to indicate the stream does not belong to a process */
 
 
    uint8_t  shared;                   
    ino_t    inode;                    
    int8_t   location;                 
    uint8_t  status;                   
    uint64_t flag;                     
    uint8_t  logflag;                  
    uint16_t sem;                      
    uint16_t NBproctrace;              
    uint64_t : 0; // align array to 8-byte boundary for speed
 
    uint64_t cnt0;                  
    uint64_t cnt1;                  
    uint64_t cnt2;                  
    uint8_t  write;                 
    uint16_t NBkw;                  
    cudaIpcMemHandle_t cudaMemHandle;
 
#ifdef DATA_PACKED
} __attribute__((__packed__)) IMAGE_METADATA;
#else
} IMAGE_METADATA;
#endif
 
 
 
typedef struct
{
    int             triggermode;
    pid_t           procwrite_PID;        
    ino_t           trigger_inode;        
    struct timespec ts_procstart;         
    struct timespec ts_streamupdate;      
    int             trigsemindex;         
    int             triggerstatus;
    uint64_t        cnt0;                 
} STREAM_PROC_TRACE;
 
 
 
typedef struct 
{
    char name[STRINGMAXLEN_IMAGE_NAME];     
    uint8_t used;
 
    int32_t shmfd; 
    uint64_t memsize; 
    sem_t *semlog; 
    IMAGE_METADATA *md;
 
 
    uint64_t : 0; // align array to 8-byte boundary for speed
 
    union {
        void *raw;  // raw pointer
 
        uint8_t *UI8;  // char
        int8_t *SI8;
 
        uint16_t *UI16;  // unsigned short
        int16_t *SI16;
 
        uint32_t *UI32;
        int32_t *SI32;  // int
 
        uint64_t *UI64;
        int64_t *SI64;  // long
 
        float *F;
        double *D;
 
        complex_float *CF;
        complex_double *CD;
 
    } array; 
    // Semaphores
 
    sem_t **semptr;                    
    IMAGE_KEYWORD *kw;
 
 
    // PID of process that read shared memory stream
    // Initialized at 0. Otherwise, when process is waiting on semaphore, its PID is written in this array
    // The array can be used to look for available semaphores
    pid_t *semReadPID;
 
    // PID of the process posting the semaphores
    pid_t *semWritePID;
 
    // array
    // keeps track of stream history/depedencies
    STREAM_PROC_TRACE *streamproctrace;
 
 
    uint64_t *flagarray;               
    uint64_t *cntarray;                
    struct timespec *atimearray;       
    struct timespec *writetimearray;   
#ifdef DATA_PACKED
} __attribute__((__packed__)) IMAGE;
#else
} IMAGE;
#endif
 
#ifdef __cplusplus
}  // extern "C"
#endif
 
#endif