types.h

/* Jazz (c) 2018-2025 kaalam.ai (The Authors of Jazz), using (under the same license):
 
    1. Biomodelling - The AATBlockQueue class (c) Jacques Basaldúa, 2009-2012 licensed
      exclusively for the use in the Jazz server software.
 
      Copyright 2009-2012 Jacques Basaldúa
 
    2. BBVA - Jazz: A lightweight analytical web server for data-driven applications.
 
      Copyright 2016-2017 Banco Bilbao Vizcaya Argentaria, S.A.
 
      This product includes software developed at
 
      BBVA (https://www.bbva.com/)
 
    3. LMDB, Copyright 2011-2017 Howard Chu, Symas Corp. All rights reserved.
 
      Licensed under http://www.OpenLDAP.org/license.html
 
 
      Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
      http://www.apache.org/licenses/LICENSE-2.0
 
      Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/
 
 
#include "src/include/jazz_platform.h"
 
 
#include <map>
#include <set>
#include <chrono>
#include <stdint.h>
#include <string>
 
 
#ifdef CATCH_TEST
#ifndef INCLUDED_JAZZ_CATCH2
#define INCLUDED_JAZZ_CATCH2
 
#include "src/catch2/catch.hpp"
 
#endif
#endif
 
 
#ifndef INCLUDED_JAZZ_ELEMENTS_TYPES
#define INCLUDED_JAZZ_ELEMENTS_TYPES
 
 
namespace jazz_elements
{
 
#define SHORT_NAME_SIZE          8              
#define NAME_SIZE               32              
#define NAME_LENGTH             NAME_SIZE - 1   
#define ONE_MB                  (1024*1024)     
 
#define JAZZ_MAX_NUM_THREADS    64
 
#define MAX_TENSOR_RANK         6           
#define MAX_CHECKS_4_MATCH      25          
#define MAX_ITEMS_IN_KIND       64          
 
#define CELL_TYPE__
 
#define CELL_TYPE_UNDEFINED     0x000       
 
// 8 bit cell types
#define CELL_TYPE_BYTE          0x001       
#define CELL_TYPE_BYTE_BOOLEAN  0x101       
#define CELL_TYPE_INT8          0x201       
 
// 16 bit cell types (Introduced for Bop-25)
 
#define CELL_TYPE_INT16         0x002       
#define CELL_TYPE_UINT16        0x102       
#define CELL_TYPE_FLOAT16       0x202       
#define CELL_TYPE_BFLOAT16      0x302       
 
// 32 bit cell types
#define CELL_TYPE_INTEGER       0x004       
#define CELL_TYPE_FACTOR        0x104       
#define CELL_TYPE_GRADE         0x204       
#define CELL_TYPE_BOOLEAN       0x304       
#define CELL_TYPE_SINGLE        0x404       
#define CELL_TYPE_STRING        0x504       
#define CELL_TYPE_UINT32        0x604       
 
// 64 bit cell types
#define CELL_TYPE_LONG_INTEGER  0x008       
#define CELL_TYPE_TIME          0x108       
#define CELL_TYPE_DOUBLE        0x208       
#define CELL_TYPE_UINT64        0x308       
 
// 40 byte cell types
#define CELL_TYPE_TUPLE_ITEM    0x028       
#define CELL_TYPE_KIND_ITEM     0x128       
 
// 48 byte cell types
#define CELL_TYPE_INDEX         0x030       
 
// Special cell types (Used in onnx::AttributeProto::AttributeType)
#define CELL_TYPE_ONNX_GRAPH    0x040       
#define CELL_TYPE_ONNX_TENSOR   0x140       
 
// NA values or empty string values for all cell_type values
#define BYTE_BOOLEAN_NA         0x0ff       
#define BOOLEAN_NA              0x0ff       
#define FLOAT16_NA              F16_NA      
#define BFLOAT16_NA             BF16_NA     
#define INTEGER_NA              INT_MIN     
#define SINGLE_NA               F_NA        
#define STRING_NA               0           
#define STRING_EMPTY            1           
#define LONG_INTEGER_NA         LLONG_MIN   
#define TIME_POINT_NA           0           
#define DOUBLE_NA               R_NA        
 
#define SINGLE_NA_UINT32        F_NA_uint32 
#define DOUBLE_NA_UINT64        R_NA_uint64 
 
 
#define MIXED_TYPE_
 
#define MIXED_TYPE_INVALID      0           
#define MIXED_TYPE_KIND         1           
#define MIXED_TYPE_TUPLE        2           
 
 
#define BLOCK_ATTRIB_
 
#define BLOCK_ATTRIB_BLOCKTYPE  1           
#define BLOCK_ATTRIB_SOURCE     2           
#define BLOCK_ATTRIB_DEST       3           
#define BLOCK_ATTRIB_MIMETYPE   4           
#define BLOCK_ATTRIB_URL        5           
#define BLOCK_ATTRIB_LANGUAGE   6           
#define BLOCK_ATTRIB_SNIPSTATE  7           
#define BLOCK_ATTRIB_SNIPVERS   8           
 
#define SET_HAS_NA_
 
#define SET_HAS_NA_FALSE        0           
#define SET_HAS_NA_TRUE         1           
#define SET_HAS_NA_AUTO         2           
 
 
typedef std::chrono::steady_clock::time_point TimePoint;    
 
 
typedef char Name[NAME_SIZE];
typedef Name *pName;                        
typedef char *pChar;                        
 
 
struct TensorDim {
    int dim[MAX_TENSOR_RANK];   
};
 
 
struct ItemHeader {
    int cell_type;              
    int name;                   
    int rank;                   
    int dim[MAX_TENSOR_RANK];   
    union {
        int data_start;         
        int item_size;          
    };
};
 
 
typedef uint16_t ff_fp16;       
 
 
union Tensor {
    uint8_t    cell_byte[0];        
    int8_t     cell_int8[0];        
    bool       cell_bool[0];        
 
    int16_t    cell_int16[0];       
    uint16_t   cell_word[0];        
    ff_fp16    cell_float16[0];     
 
    int        cell_int[0];         
    uint32_t   cell_uint[0];        
    float      cell_single[0];      
 
    long long  cell_longint[0];     
    time_t     cell_time[0];        
    uint64_t   cell_ulongint[0];    
    double     cell_double[0];      
    ItemHeader cell_item[0];        
};
 
 
typedef std::set<std::string> Dimensions;               
 
 
typedef std::map<std::string, std::string>  Index;      
 
 
struct BlockHeader {
    int cell_type;                      
    int size;                           
    TimePoint created;                  
    union {
        struct {
            int rank;                   
            TensorDim range;            
            int num_attributes;         
            int total_bytes;            
            bool has_NA;                
            uint64_t hash64;            
 
            Tensor tensor;              
 
        };
        Index index;                    
    };
};
typedef BlockHeader *pBlockHeader;      
 
 
struct StaticBlockHeader {
    int cell_type;                      
    int size;                           
    TimePoint created;                  
    int rank;                           
    TensorDim range;                    
    int num_attributes;                 
    int total_bytes;                    
    bool has_NA;                        
    uint64_t hash64;                    
 
    Tensor tensor;                      
};
typedef StaticBlockHeader *pStaticBlockHeader;  
 
 
struct StringBuffer {
    bool stop_check_4_match;            
    bool alloc_failed;                  
    int  last_idx;                      
    int  buffer_size;                   
    char buffer[];                      
};
typedef StringBuffer *pStringBuffer;    
 
 
extern float  F_NA;     
extern double R_NA;     
 
} // namespace jazz_elements
 
#endif // ifndef INCLUDED_JAZZ_ELEMENTS_TYPES