Cache.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2009 Benoit Bolsee
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later */
 
#ifndef CACHE_HPP_
#define CACHE_HPP_
 
#include <map>
 
namespace iTaSC {
 
#define CACHE_LOOKUP_TABLE_SIZE             128
#define CACHE_DEFAULT_BUFFER_SIZE           32768
#define CACHE_CHANNEL_EXTEND_SIZE           10
#define CACHE_MAX_ITEM_SIZE                 0x3FFF0
 
/* macro to get the alignment gap after an item header */
#define CACHE_ITEM_GAPB(item)               (unsigned int)(((size_t)item+sizeof(CacheItem))&(sizeof(void*)-1))
/* macro to get item data position, item=CacheItem pointer */
#define CACHE_ITEM_DATA_POINTER(item)       (void*)((unsigned char*)item+sizeof(CacheItem)+CACHE_ITEM_GAPB(item))
/* macro to get item size in 32bit words from item address and length, item=CacheItem pointer */
#define CACHE_ITEM_SIZEW(item,length)       (unsigned int)((sizeof(CacheItem)+CACHE_ITEM_GAPB(item)+(((length)+3)&~0x3))>>2)
/* macto to move from one item to the next, item=CacheItem pointer, updated by the macro */
#define CACHE_NEXT_ITEM(item)               ((item)+(item)->m_sizeW)
#define CACHE_BLOCK_ITEM_ADDR(chan,buf,block)   (&(buf)->m_firstItem+(((unsigned int)(block)<<chan->m_positionToBlockShiftW)+(buf)->lookup[block].m_offsetW))
#define CACHE_ITEM_ADDR(buf,pos)            (&(buf)->m_firstItem+(pos))
#define CACHE_ITEM_POSITIONW(buf,item)      (unsigned int)(item-&buf->m_firstItem)
 
typedef unsigned int CacheTS;
 
struct Timestamp 
{
    double realTimestamp;
    double realTimestep;
    CacheTS cacheTimestamp;
    unsigned int numstep:8;
    unsigned int substep:1;
    unsigned int reiterate:1;
    unsigned int cache:1;
    unsigned int update:1;
    unsigned int interpolate:1;
    unsigned int dummy:19;
 
    Timestamp() { memset(this, 0, sizeof(Timestamp)); }
};
 
/* utility function to return second timestamp to millisecond */
inline void setCacheTimestamp(Timestamp& timestamp)
{
    if (timestamp.realTimestamp < 0.0 || timestamp.realTimestamp > 4294967.295)
        timestamp.cacheTimestamp = 0;
    else
        timestamp.cacheTimestamp = (CacheTS)(timestamp.realTimestamp*1000.0+0.5);
}
 
 
/*
class Cache:
Top level class, only one instance of this class should exists.
A device (=constraint, object) uses this class to create a cache entry for its data.
A cache entry is divided into cache channels, each providing a separate buffer for cache items.
The cache channels must be declared by the devices before they can be used.
The device must specify the largest cache item (limited to 256Kb) so that the cache
buffer can be organized optimally.
Cache channels are identified by small number (starting from 0) allocated by the cache system.
Cache items are inserted into cache channels ordered by timestamp. Writing is always done
at the end of the cache buffer: writing an item automatically clears all items with 
higher timestamp.
A cache item is an array of bytes provided by the device; the format of the cache item is left 
to the device. 
The device can retrieve a cache item associated with a certain timestamp. The cache system
returns a pointer that points directly in the cache buffer to avoid unnecessary copy. 
The pointer is guaranteed to be pointer aligned so that direct mapping to C structure is possible 
(=32 bit aligned on 32 systems and 64 bit aligned on 64 bits system).
 
Timestamp = rounded time in millisecond.
*/
 
struct CacheEntry;
struct CacheBuffer;
struct CacheItem;
struct CacheChannel;
 
class Cache 
{
private:
    /* map between device and cache entry.
       Dynamically updated when more devices create cache channels */
    typedef std::map<const void *, struct CacheEntry*> CacheMap;
    CacheMap  m_cache;
    const CacheItem *getCurrentCacheItemInternal(const void *device, int channel, CacheTS timestamp);
   
public:
    Cache();
    ~Cache();
    /* add a cache channel, maxItemSize must be < 256k.
       name : channel name, truncated at 31 characters
       msxItemSize : maximum size of item in bytes, items of larger size will be rejected
       return value >= 0: channel id, -1: error */
    int addChannel(const void *device, const char *name, unsigned int maxItemSize);
 
    /* delete a cache channel (and all associated buffers and items) */
    int deleteChannel(const void *device, int channel);
    /* delete all channels of a device and remove the device from the map */
    int deleteDevice(const void *device);
    /* removes all cache items, leaving the special item at timestamp=0. 
       if device=NULL, apply to all devices. */
    void clearCacheFrom(const void *device, CacheTS timestamp);
 
    /* add a new cache item
       channel: the cache channel (as returned by AddChannel
       data, length: the cache item and length in bytes
                     If data is NULL, the memory is allocated in the cache but not writen
       return: error: NULL, success: pointer to item in cache */
    void *addCacheItem(const void *device, int channel, CacheTS timestamp, void *data, unsigned int length);
 
    /* specialized function to add a vector of double in the cache
       It will first check if a vector exist already in the cache for the same timestamp
       and compared the cached vector with the new values. 
       If all values are within threshold, the vector is updated but the cache is not deleted
       for the future timestamps. */
    double *addCacheVectorIfDifferent(const void *device, int channel, CacheTS timestamp, double *data, unsigned int length, double threshold);
 
    /* returns the cache item with timestamp that is just before the given timestamp.
       returns the data pointer or NULL if there is no cache item before timestamp.
       On return, timestamp is updated with the actual timestamp of the item being returned.
       Note that the length of the item is not returned, it is up to the device to organize
       the data so that length can be retrieved from the data if needed.
       Device can NULL, it will then just look the first channel available, useful to 
       test the status of the cache. */
    const void *getPreviousCacheItem(const void *device, int channel, CacheTS *timestamp);
 
    /* returns the cache item with the timestamp that is exactly equal to the given timestamp
       If there is no cache item for this timestamp, returns NULL.*/
    const void *getCurrentCacheItem(const void *device, int channel, CacheTS timestamp);
 
};
 
/* the following structures are not internal use only, they should not be used directly */
 
struct CacheEntry 
{
    CacheChannel *m_channelArray;       // array of channels, automatically resized if more channels are created
    unsigned int m_count;               // number of channel in channelArray
    CacheEntry() : m_channelArray(NULL), m_count(0) {}
    ~CacheEntry();
};
 
struct CacheChannel
{
    CacheItem* initItem;                // item corresponding to timestamp=0
    struct CacheBuffer *m_firstBuffer;  // first buffer of list
    struct CacheBuffer *m_lastBuffer;       // last buffer of list to which an item was written
    char m_name[32];                        // channel name
    unsigned char m_busy;                   // =0 if channel is free, !=0 when channel is in use
    unsigned char m_positionToBlockShiftW;  // number of bits to shift a position in word to get the block number
    unsigned short m_positionToOffsetMaskW;   // bit mask to apply on a position in word to get offset in a block
    unsigned int m_maxItemSizeB;            // maximum item size in bytes
    unsigned int m_bufferSizeW;         // size of item buffer in word to allocate when a new buffer must be created
    unsigned int m_blockSizeW;          // block size in words of the lookup table
    unsigned int m_lastTimestamp;           // timestamp of the last item that was written
    unsigned int m_lastItemPositionW;       // position in words in lastBuffer of the last item written
    void clear();
    CacheBuffer* allocBuffer();
    CacheItem* findItemOrLater(unsigned int timestamp, CacheBuffer **rBuffer);
    CacheItem* findItemEarlier(unsigned int timestamp, CacheBuffer **rBuffer);
    // Internal function: finds an item in a buffer that is < timeOffset
    // timeOffset must be a valid offset for the buffer and the buffer must not be empty
    // on return highBlock contains the block with items above or equal to timeOffset
    CacheItem *_findBlock(CacheBuffer *buffer, unsigned short timeOffset, unsigned int *highBlock);
};
 
struct CacheBlock {
    unsigned short m_timeOffset;        // timestamp relative to m_firstTimestamp
    unsigned short m_offsetW;           // position in words of item relative to start of block
};
 
/* CacheItem is the header of each item in the buffer, must be 32bit
   Items are always 32 bits aligned and size is the number of 32 bit words until the
   next item header, including an eventual pre and post padding gap for pointer alignment */
struct CacheItem
{
    unsigned short m_timeOffset;        // timestamp relative to m_firstTimestamp
    unsigned short m_sizeW;         // size of item in 32 bit words
    // item data follows header immediately or after a gap if position is not pointer aligned
};
 
// Buffer header
// Defined in a macro to avoid sizeof() potential problem.
//  next                for linked list. = NULL for last buffer
//  m_firstTimestamp        timestamp of first item in this buffer
//  m_lastTimestamp     timestamp of last item in this buffer
//                      m_lastTimestamp must be < m_firstTimestamp+65536
//  m_lastItemPositionW position in word of last item written
//  m_firstFreePositionW    position in word where a new item can be written, 0 if buffer is empty
//  lookup              lookup table for fast access to item by timestamp
//                      The buffer is divided in blocks of 2**n bytes with n chosen so that 
//                      there are no more than CACHE_LOOKUP_TABLE_SIZE blocks and that each 
//                      block will contain at least one item. 
//                      Each element of the lookup table gives the timestamp and offset 
//                      of the last cache item occupying (=starting in) the corresponding block.
#define CACHE_HEADER \
    struct CacheBuffer *m_next;     \
    unsigned int m_firstTimestamp;  \
    unsigned int m_lastTimestamp;       \
                                    \
    unsigned int m_lastItemPositionW;   \
    unsigned int m_firstFreePositionW;\
    struct CacheBlock lookup[CACHE_LOOKUP_TABLE_SIZE]
 
struct CacheBufferHeader {
    CACHE_HEADER;
};
#define CACHE_BUFFER_HEADER_SIZE    (sizeof(struct CacheBufferHeader))
struct CacheBuffer
{
    CACHE_HEADER;
    struct CacheItem m_firstItem;           // the address of this field marks the start of the buffer
};
 
 
}
 
#endif /* CACHE_HPP_ */