[dev-alloc] pimAlloc updates

libpimeval/src/libpimeval.cpp

@@ -71,6 +71,20 @@ pimAllocAssociated(PimObjId assocId, PimDataType dataType)
   return pimSim::get()->pimAllocAssociated(bitsPerElement, assocId, dataType);
 }
 
+//! @brief  Allocate a PIM resource
+PimObjId
+pimAllocCustomized(PimAllocEnum allocType, uint64_t numElements, PimDataType dataType, unsigned bitsPerElement)
+{
+  return pimSim::get()->pimAlloc(allocType, numElements, bitsPerElement, dataType);
+}
+
+//! @brief  Allocate a PIM resource, with an associated object as reference
+PimObjId
+pimAllocAssociatedCustomized(PimObjId assocId, PimDataType dataType, unsigned bitsPerElement)
+{
+  return pimSim::get()->pimAllocAssociated(bitsPerElement, assocId, dataType);
+}
+
 //! @brief  Free a PIM resource
 PimStatus
 pimFree(PimObjId obj)

libpimeval/src/libpimeval.h

@@ -49,7 +49,8 @@ enum PimCopyEnum {
 
 //! @brief  PIM datatypes
 enum PimDataType {
-  PIM_INT8 = 0,
+  PIM_BOOL = 0,
+  PIM_INT8,
   PIM_INT16,
   PIM_INT32,
   PIM_INT64,
@@ -142,6 +143,10 @@ PimStatus pimShiftElementsLeft(PimObjId src);
 PimStatus pimShiftBitsRight(PimObjId src, PimObjId dest, unsigned shiftAmount);
 PimStatus pimShiftBitsLeft(PimObjId src, PimObjId dest, unsigned shiftAmount);
 
+////////////////////////////////////////////////////////////////////////////////
+// Warning: Do not use below micro-ops level APIs for functional simulation   //
+////////////////////////////////////////////////////////////////////////////////
+
 // BitSIMD micro ops
 // Note: Below APIs are for low-level micro-ops programming but not for functional simulation
 // BitSIMD-V: Row-wide bit registers per subarray
@@ -155,6 +160,9 @@ enum PimRowReg {
   PIM_RREG_R5,
 };
 
+// Customized allocation with bitsPerElement less than the number of bits of dataType
+PimObjId pimAllocCustomized(PimAllocEnum allocType, uint64_t numElements, PimDataType dataType, unsigned bitsPerElement);
+PimObjId pimAllocAssociatedCustomized(PimObjId assocId, PimDataType dataType, unsigned bitsPerElement);
 // BitSIMD-V micro ops
 PimStatus pimOpReadRowToSa(PimObjId src, unsigned ofst);
 PimStatus pimOpWriteSaToRow(PimObjId src, unsigned ofst);

libpimeval/src/pimResMgr.cpp

@@ -102,6 +102,9 @@ pimResMgr::~pimResMgr()
 }
 
 //! @brief  Alloc a PIM object
+//!         Expect bitsPerElement to be smaller than or equal to the width of dataType
+//!         For V layout, allocate bitsPerElement rows
+//!         For H layout, pad element to the width of dataType
 PimObjId
 pimResMgr::pimAlloc(PimAllocEnum allocType, uint64_t numElements, unsigned bitsPerElement, PimDataType dataType)
 {
@@ -114,6 +117,12 @@ pimResMgr::pimAlloc(PimAllocEnum allocType, uint64_t numElements, unsigned bitsP
     std::printf("PIM-Error: Invalid parameters to allocate %llu elements of %u bits\n", numElements, bitsPerElement);
     return -1;
   }
+  unsigned bitsOfDataType = pimUtils::getNumBitsOfDataType(dataType);
+  if (bitsPerElement > bitsOfDataType) {
+    std::printf("PIM-Error: Cannot allocate %u bits which is greater than the width of %s data type\n",
+                bitsPerElement, pimUtils::pimDataTypeEnumToStr(dataType).c_str());
+    return -1;
+  }
 
   std::vector<PimCoreId> sortedCoreId = getCoreIdsSortedByLeastUsage();
   pimObjInfo newObj(m_availObjId, dataType, allocType, numElements, bitsPerElement);
@@ -141,8 +150,8 @@ pimResMgr::pimAlloc(PimAllocEnum allocType, uint64_t numElements, unsigned bitsP
   } else if (allocType == PIM_ALLOC_H || allocType == PIM_ALLOC_H1) {
     // allocate one region per core, with horizontal layout
     numRowsToAlloc = 1;
-    numRegions = (numElements * bitsPerElement - 1) / numCols + 1;
-    numColsToAllocLast = (numElements * bitsPerElement) % numCols;
+    numRegions = (numElements * bitsOfDataType - 1) / numCols + 1;
+    numColsToAllocLast = (numElements * bitsOfDataType) % numCols;
     if (numColsToAllocLast == 0) {
       numColsToAllocLast = numCols;
     }
@@ -156,7 +165,8 @@ pimResMgr::pimAlloc(PimAllocEnum allocType, uint64_t numElements, unsigned bitsP
 
   if (numRegions > numCores) {
     if (allocType == PIM_ALLOC_V1 || allocType == PIM_ALLOC_H1) {
-      std::printf("PIM-Error: Obj requires %llu regions among %u cores. Abort.\n", numRegions, numCores);
+      std::printf("PIM-Error: Obj requires %llu regions among %u cores. Abort since wrapping up is disabled.\n",
+                  numRegions, numCores);
       return -1;
     } else {
       #if defined(DEBUG)
@@ -165,7 +175,7 @@ pimResMgr::pimAlloc(PimAllocEnum allocType, uint64_t numElements, unsigned bitsP
     }
   }
 
-  // create new regions
+  // create regions
   bool success = true;
   for (unsigned i = 0; i < numCores; ++i) {
     m_coreUsage.at(i)->newAllocStart();
@@ -218,8 +228,11 @@ pimResMgr::pimAlloc(PimAllocEnum allocType, uint64_t numElements, unsigned bitsP
 }
 
 //! @brief  Alloc a PIM object assiciated to an existing object
-//!         For V layout, expect same number of elements, while bits per element may be different
-//!         For H layout, expect exact same number of elements and bits per elements
+//!         Expect bitsPerElement to be smaller than or equal to the width of dataType
+//!         Expect dataType to be narrower or equal to the width of associated dataType
+//!         For V layout, allocate bitsPerElement rows
+//!         For H layout, pad element to the width of assiciated dataType
+//!         Number of elements will be the same as the assiciated object
 PimObjId
 pimResMgr::pimAllocAssociated(unsigned bitsPerElement, PimObjId assocId, PimDataType dataType)
 {
@@ -233,6 +246,12 @@ pimResMgr::pimAllocAssociated(unsigned bitsPerElement, PimObjId assocId, PimData
     std::printf("PIM-Error: Invalid associated object ID %d for PIM allocation\n", assocId);
     return -1;
   }
+  unsigned bitsOfDataType = pimUtils::getNumBitsOfDataType(dataType);
+  if (bitsPerElement > bitsOfDataType) {
+    std::printf("PIM-Error: Cannot allocate %u bits which is greater than the width of %s data type\n",
+                bitsPerElement, pimUtils::pimDataTypeEnumToStr(dataType).c_str());
+    return -1;
+  }
 
   // get regions of the assoc obj
   unsigned numCores = m_device->getNumCores();
@@ -241,10 +260,13 @@ pimResMgr::pimAllocAssociated(unsigned bitsPerElement, PimObjId assocId, PimData
   // check if the request can be associated with ref
   PimAllocEnum allocType = assocObj.getAllocType();
   uint64_t numElements = assocObj.getNumElements();
+  PimDataType assocDataType = assocObj.getDataType();
+  unsigned bitsOfAssocDataType = pimUtils::getNumBitsOfDataType(assocDataType);
   if (allocType == PIM_ALLOC_H || allocType == PIM_ALLOC_H1) {
-    if (bitsPerElement != assocObj.getBitsPerElement()) {
-      std::printf("PIM-Error: Cannot allocate elements of %u bits associated with object ID %d with %u bits in H1 style\n",
-                  bitsPerElement, assocId, assocObj.getBitsPerElement());
+    if (bitsOfDataType > bitsOfAssocDataType) {
+      std::printf("PIM-Error: Cannot associate or pad a wider %s data type to %s data type\n",
+                  pimUtils::pimDataTypeEnumToStr(dataType).c_str(),
+                  pimUtils::pimDataTypeEnumToStr(assocDataType).c_str());
       return -1;
     }
   }

libpimeval/src/pimResMgr.h

@@ -106,6 +106,7 @@ class pimObjInfo
   PimDataType getDataType() const { return m_dataType; }
   uint64_t getNumElements() const { return m_numElements; }
   unsigned getBitsPerElement() const { return m_bitsPerElement; }
+  unsigned getBitsPerElementPadded() const { return m_bitsPerElementPadded; }
   bool isValid() const { return m_numElements > 0 && m_bitsPerElement > 0 && !m_regions.empty(); }
   bool isVLayout() const { return m_allocType == PIM_ALLOC_V || m_allocType == PIM_ALLOC_V1; }
   bool isHLayout() const { return m_allocType == PIM_ALLOC_H || m_allocType == PIM_ALLOC_H1; }
@@ -128,6 +129,7 @@ class pimObjInfo
   PimAllocEnum m_allocType;
   uint64_t m_numElements = 0;
   unsigned m_bitsPerElement = 0;
+  unsigned m_bitsPerElementPadded = 0;
   std::vector<pimRegion> m_regions;  // a list of core ID and regions
   unsigned m_maxNumRegionsPerCore = 0;
   unsigned m_numCoresUsed = 0;

libpimeval/src/pimUtils.cpp

@@ -76,6 +76,7 @@ std::string
 pimUtils::pimDataTypeEnumToStr(PimDataType dataType)
 {
   switch (dataType) {
+  case PIM_BOOL: return "bool";
   case PIM_INT8: return "int8";
   case PIM_INT16: return "int16";
   case PIM_INT32: return "int32";
@@ -94,6 +95,7 @@ unsigned
 pimUtils::getNumBitsOfDataType(PimDataType dataType)
 {
   switch (dataType) {
+  case PIM_BOOL: return 1;
   case PIM_INT8: return 8;
   case PIM_INT16: return 16;
   case PIM_INT32: return 32;

tests/test-padding/Makefile

@@ -0,0 +1,19 @@
+# Makefile: Test PIM alloc and padding
+# Copyright (c) 2024 University of Virginia
+# This file is licensed under the MIT License.
+# See the LICENSE file in the root of this repository for more details.
+
+PROJ_ROOT = ../..
+include ${PROJ_ROOT}/Makefile.common
+
+EXEC := test-padding.out
+SRC := test-padding.cpp
+
+debug perf dramsim3_integ: $(EXEC)
+
+$(EXEC): $(SRC) $(DEPS)
+	$(CXX) $< $(CXXFLAGS) -o $@
+
+clean:
+	rm -rf $(EXEC) *.dSYM
+

tests/test-padding/test-padding.cpp

@@ -0,0 +1,109 @@
+// Test: Test PIM alloc
+// Copyright (c) 2024 University of Virginia
+// This file is licensed under the MIT License.
+// See the LICENSE file in the root of this repository for more details.
+
+#include "libpimeval.h"
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <bitset>
+#include <cassert>
+#include <cstdlib>
+#include <cstdio>
+
+
+void testAlloc(PimDeviceEnum deviceType)
+{
+  // 1GB capacity
+  unsigned numRanks = 1;
+  unsigned numBankPerRank = 1;
+  unsigned numSubarrayPerBank = 4;
+  unsigned numRows = 1024;
+  unsigned numCols = 8192;
+
+  uint64_t numElements = 32 * 1024;
+
+  std::vector<int> srcInt(numElements);
+  std::vector<int> srcIntNarrow(numElements);
+  std::vector<char> srcChar(numElements);
+  std::vector<char> srcCharNarrow(numElements);
+
+  for (uint64_t i = 0; i < numElements; ++i) {
+    srcInt[i] = static_cast<int>(i);
+    srcIntNarrow[i] = (srcInt[i] & 0xffffff);
+    srcChar[i] = i % 256;
+    srcCharNarrow[i] = (srcChar[i] & 0xf);
+  }
+
+  PimStatus status = pimCreateDevice(deviceType, numRanks, numBankPerRank, numSubarrayPerBank, numRows, numCols);
+  assert(status == PIM_OK);
+
+  // test PIM allocation
+  PimObjId objInt = pimAlloc(PIM_ALLOC_AUTO, numElements, PIM_INT32);
+  PimObjId objIntNarrow = pimAllocCustomized(PIM_ALLOC_AUTO, numElements, PIM_INT32, 24/*bitsPerElement*/);
+  PimObjId objChar = pimAlloc(PIM_ALLOC_AUTO, numElements, PIM_INT8);
+  PimObjId objCharNarrow = pimAllocCustomized(PIM_ALLOC_AUTO, numElements, PIM_INT8, 4/*bitsPerElement*/);
+  assert(objInt != -1);
+  assert(objIntNarrow != -1);
+  assert(objChar != -1);
+  assert(objCharNarrow != -1);
+
+  // copy host to device
+  status = pimCopyHostToDevice((void*)srcInt.data(), objInt);
+  assert(status == PIM_OK);
+  status = pimCopyHostToDevice((void*)srcInt.data(), objIntNarrow); // auto truncate
+  assert(status == PIM_OK);
+  status = pimCopyHostToDevice((void*)srcChar.data(), objChar);
+  assert(status == PIM_OK);
+  status = pimCopyHostToDevice((void*)srcChar.data(), objCharNarrow); // auto truncate
+  assert(status == PIM_OK);
+
+  std::vector<int> destInt(numElements);
+  std::vector<int> destIntNarrow(numElements);
+  std::vector<char> destChar(numElements);
+  std::vector<char> destCharNarrow(numElements);
+
+  status = pimCopyDeviceToHost(objInt, (void*)destInt.data());
+  assert(status == PIM_OK);
+  status = pimCopyDeviceToHost(objIntNarrow, (void*)destIntNarrow.data());
+  assert(status == PIM_OK);
+  status = pimCopyDeviceToHost(objChar, (void*)destChar.data());
+  assert(status == PIM_OK);
+  status = pimCopyDeviceToHost(objCharNarrow, (void*)destCharNarrow.data());
+  assert(status == PIM_OK);
+
+  if (srcInt != destInt) {
+    std::printf("ERROR: Incorrect int32 values\n");
+  }
+  if (srcIntNarrow != destIntNarrow) {
+    std::printf("ERROR: Incorrect int32 truncated values\n");
+  }
+  if (srcChar != destChar) {
+    std::printf("ERROR: Incorrect int8 values\n");
+  }
+  if (srcCharNarrow != destCharNarrow) {
+    std::printf("ERROR: Incorrect int8 truncated values\n");
+  }
+
+  pimFree(objInt);
+  pimFree(objIntNarrow);
+  pimFree(objChar);
+  pimFree(objCharNarrow);
+
+  pimShowStats();
+  pimResetStats();
+  pimDeleteDevice();
+}
+
+int main()
+{
+  std::cout << "PIM Regression Test: PIM alloc and padding" << std::endl;
+
+  testAlloc(PIM_DEVICE_BITSIMD_V);
+
+  testAlloc(PIM_DEVICE_FULCRUM);
+
+  return 0;
+}
+