sdata.hxx

// dawn/include/dawn/io/sdata.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include <cassert>
#include <cstddef>
#include <cstdlib>
#include <cstring>
 
#include "dawn/io/idata.hxx"
#include "dawn/porting/config.hxx"
 
namespace dawn
{
template<typename T, size_t N>
struct io_data_s
{
  io_ts_t ts; 
  T data[N];  
};
 
template<typename T, size_t N>
struct io_data_nots_s
{
  T data[N]; 
};
 
template<typename T, size_t N, size_t M = 1, bool TS = false>
struct io_sdata_t : public io_data_cmn_t
{
  io_data_nots_s<T, N> data[M]; 
  io_ts_t dummyTs;              
 
  io_sdata_t()
    : data{}
    , dummyTs(0)
  {
    assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8);
  }
 
  constexpr T &operator()(size_t index, size_t batch = 0)
  {
    assert(index < N);
    assert(batch < M);
    return data[batch].data[index];
  }
 
  constexpr io_ts_t &operator[](size_t batch)
  {
    (void)batch;
    return dummyTs;
  }
 
  constexpr static size_t getSize()
  {
    return sizeof(T);
  }
 
  constexpr size_t getItems() override
  {
    return N;
  }
 
  constexpr static size_t getBatch()
  {
    return M;
  }
 
  constexpr size_t getBufferSize() const
  {
    return sizeof(this->data);
  }
 
  constexpr size_t getDataSize() override
  {
    return sizeof(T) * N;
  }
 
  constexpr void *getPtr(size_t batch = 0) override
  {
    return (void *)&data[batch];
  }
 
  constexpr void *getDataPtr(size_t batch = 0) override
  {
    return (void *)&data[batch];
  }
 
  bool hasTimestamp() override
  {
    return false;
  }
 
  constexpr io_ts_t &getTs(size_t batch = 0) override
  {
    (void)batch;
    return dummyTs;
  };
};
 
template<typename T, size_t N, size_t M>
struct io_sdata_t<T, N, M, true> : public io_data_cmn_t
{
  io_data_s<T, N> data[M];
 
  io_sdata_t()
    : data{}
  {
    assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8);
  }
 
  constexpr T &operator()(size_t index, size_t batch = 0)
  {
    assert(index < N);
    assert(batch < M);
    return data[batch].data[index];
  }
 
  constexpr io_ts_t &operator[](size_t batch)
  {
    assert(batch < M);
    return data[batch].ts;
  }
 
  constexpr static size_t getSize()
  {
    return sizeof(T);
  }
 
  constexpr size_t getItems() override
  {
    return N;
  }
 
  constexpr static size_t getBatch()
  {
    return M;
  }
 
  constexpr size_t getBufferSize() const
  {
    return sizeof(this->data);
  }
 
  constexpr size_t getDataSize() override
  {
    return sizeof(T) * N;
  }
 
  constexpr void *getPtr(size_t batch = 0) override
  {
    return (void *)&data[batch];
  }
 
  constexpr void *getDataPtr(size_t batch = 0) override
  {
    return (void *)data[batch].data;
  }
 
  bool hasTimestamp() override
  {
    return true;
  }
 
  constexpr io_ts_t &getTs(size_t batch = 0) override
  {
    return data[batch].ts;
  };
};
 
} // Namespace dawn