objectid.hxx

// dawn/include/dawn/common/objectid.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include <cstdint>
#include <cstdlib>
 
#include "dawn/debug.hxx"
#include "dawn/porting/config.hxx"
 
namespace dawn
{
struct SObjectId
{
  constexpr static size_t PRIV_MAX = 0b11111111111111;
  constexpr static size_t PRIV_SHIFT = 0;
  constexpr static size_t FLAGS_MAX = 0b11;
  constexpr static size_t FLAGS_SHIFT = 14;
  constexpr static size_t DTYPE_MAX = 0b1111;
  constexpr static size_t DTYPE_SHIFT = 16;
  constexpr static size_t EXT_MAX = 0b1;
  constexpr static size_t EXT_SHIFT = 20;
  constexpr static size_t CLS_MAX = 0b111111111;
  constexpr static size_t CLS_SHIFT = 21;
  constexpr static size_t CLS_MASK = (CLS_MAX << CLS_SHIFT);
  constexpr static size_t TYPE_MAX = 0b11;
  constexpr static size_t TYPE_SHIFT = 30;
  constexpr static size_t TYPE_MASK = (TYPE_MAX << TYPE_SHIFT);
  constexpr static size_t fCLS_ANY = 0;
 
  typedef uint32_t ObjectId;
 
  typedef uint64_t ObjectIdExt;
 
  enum
  {
    DTYPE_ANY = 0,
 
    DTYPE_BOOL = 1,
 
    DTYPE_INT8 = 2,
 
    DTYPE_UINT8 = 3,
 
    DTYPE_INT16 = 4,
 
    DTYPE_UINT16 = 5,
 
    DTYPE_INT32 = 6,
 
    DTYPE_UINT32 = 7,
 
    DTYPE_INT64 = 8,
 
    DTYPE_UINT64 = 9,
 
    DTYPE_FLOAT = 10,
 
    DTYPE_DOUBLE = 11,
 
    DTYPE_B16 = 12,
 
    DTYPE_UB16 = 13,
 
    DTYPE_CHAR = 14,
 
    DTYPE_BLOCK = 15,
 
    DTYPE_LAST = 16,
  } typedef EObjectDataType;
 
  static_assert(DTYPE_LAST - 1 <= DTYPE_MAX);
 
  enum
  {
    OBJTYPE_ANY = 0,
 
    OBJTYPE_IO = 1,
 
    OBJTYPE_PROTO = 2,
 
    OBJTYPE_PROG = 3,
 
    OBJTYPE_LAST = 4,
  } typedef EObjectIdType;
 
  static_assert(OBJTYPE_LAST - 1 <= TYPE_MAX);
 
  union
  {
    ObjectId v;
 
    struct
    {
      uint32_t priv : 14;
 
      uint32_t flags : 2;
 
      uint32_t dtype : 4;
 
      uint32_t ext : 1;
 
      uint32_t cls : 9;
 
      uint32_t type : 2;
    } s;
  } typedef UObjectId;
 
  constexpr static ObjectId objectId(uint8_t type,
                                     uint16_t cls,
                                     uint8_t dtype,
                                     uint8_t flags,
                                     uint16_t priv)
  {
    DEBUGASSERT(type <= TYPE_MAX);
    DEBUGASSERT(cls <= CLS_MAX);
    DEBUGASSERT(dtype <= DTYPE_MAX);
    DEBUGASSERT(priv <= PRIV_MAX);
 
    return (((type & TYPE_MAX) << TYPE_SHIFT) | ((cls & CLS_MAX) << CLS_SHIFT) |
            ((dtype & DTYPE_MAX) << DTYPE_SHIFT) | ((flags & FLAGS_MAX) << FLAGS_SHIFT) |
            ((priv & PRIV_MAX) << PRIV_SHIFT));
  }
 
  constexpr static uint16_t objectIdGetId(const ObjectId objid)
  {
    return ((objid >> PRIV_SHIFT) & PRIV_MAX);
  };
 
  constexpr static uint8_t objectIdGetFlags(const ObjectId objid)
  {
    return ((objid >> FLAGS_SHIFT) & FLAGS_MAX);
  };
 
  constexpr static uint8_t objectIdGetDtype(const ObjectId objid)
  {
    return ((objid >> DTYPE_SHIFT) & DTYPE_MAX);
  };
 
  constexpr static uint16_t objectIdGetCls(const ObjectId objid)
  {
    return ((objid >> CLS_SHIFT) & CLS_MAX);
  };
 
  constexpr static uint8_t objectIdGetType(const ObjectId objid)
  {
    return ((objid >> TYPE_SHIFT) & TYPE_MAX);
  };
 
  constexpr static uint32_t objectIdGetNoId(const ObjectId objid)
  {
    return objid & (~PRIV_MAX);
  };
 
  constexpr static bool objectIsIO(const UObjectId &objid)
  {
    return (objid.s.type == OBJTYPE_IO);
  };
 
  constexpr static bool objectIsProto(const UObjectId &objid)
  {
    return (objid.s.type == OBJTYPE_PROTO);
  };
 
  constexpr static bool objectIsProg(const UObjectId &objid)
  {
    return (objid.s.type == OBJTYPE_PROG);
  };
 
  constexpr static bool objectIsIO(const ObjectId objid)
  {
    return objectIdGetType(objid) == OBJTYPE_IO;
  };
 
  constexpr static bool objectIsProto(const ObjectId objid)
  {
    return objectIdGetType(objid) == OBJTYPE_PROTO;
  };
 
  constexpr static bool objectIsProg(const ObjectId objid)
  {
    return objectIdGetType(objid) == OBJTYPE_PROG;
  };
 
  constexpr static ObjectId objectMask(const ObjectId objid)
  {
    return (objid & TYPE_MASK) | (objid & CLS_MASK);
  };
 
  static int getDtypeSize_(const EObjectDataType dtype);
 
  static bool isDtypeSupported(uint8_t dtype);
 
  static const char *dtypeToString(uint8_t dtype);
};
} // Namespace dawn