ImageStruct.h

Go to the documentation of this file.

#ifndef _IMAGESTRUCT_H
#define _IMAGESTRUCT_H

#define IMAGESTRUCT_VERSION "0.0.01"

#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            
// 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[16];         
    char type;             
    uint64_t : 0;  // align array to 8-byte boundary for speed

    union {
        int64_t numl;
        double  numf;
        char    valstr[16];
    } value;

    char comment[80];
#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[80];


    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;         
    uint8_t  shared;                   
    int8_t   location;                 
    uint8_t  status;                   
    uint64_t flag;                     
    uint8_t  logflag;                  
    uint16_t sem;                      
    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 
{
    char name[80];     
    // mem offset = 80

    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; 
    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 writing the data
    pid_t *semWritePID;

    uint64_t *flagarray;               
    uint64_t *cntarray;                
    struct timespec *atimearray;       
    struct timespec *writetimearray;   
    // total size is 152 byte = 1216 bit
#ifdef DATA_PACKED
} __attribute__((__packed__)) IMAGE;
#else
} IMAGE;
#endif

#ifdef __cplusplus
}  // extern "C"
#endif

#endif