Merge pull request #5 from AMDResearch/rocm-4.0.1

ashwinma · web-flow · commit cdf6c21fa4cb · 2021-10-12T15:57:24.000-07:00
ROCm 4.0.1 updates
diff --git a/DAGEE-lib/include/dagee/ATMIgpuExecutor.h b/DAGEE-lib/include/dagee/ATMIgpuExecutor.h
@@ -9,7 +9,9 @@
 
 namespace dagee {
 
-using ATMIgpuKernelInfo = atmi_kernel_t;
+struct ATMIgpuKernelInfo {
+  atmi_kernel_t mKern;
+};
 
 // TODO(amber): Store mKernArgOffsets as part of ATMIgpuKernelInfo
 template <typename AllocFactory>
@@ -65,7 +67,7 @@ struct GpuKernelRegAtmiPolicy {
  protected:
   using KernPtrLookup = KernelPtrToNameLookup<AllocFactory>;
 
-  using KernelInfoMap = typename AllocFactory::template HashMap<GenericFuncPtr, KernelInfo>;
+  using KernelInfoMap = typename AllocFactory::template HashMap<GenericFuncPtr, atmi_kernel_t>;
 
   KernPtrLookup mKernPtrLookup;
 
@@ -119,7 +121,7 @@ struct GpuKernelRegAtmiPolicy {
     auto kiter = mGpuKernels.find(fptr);
 
     if (kiter != mGpuKernels.cend()) {
-      return kiter->second;
+      return KernelInfo{ kiter->second };
 
     } else {
       const auto& name = mKernPtrLookup.name(fptr);
@@ -132,7 +134,7 @@ struct GpuKernelRegAtmiPolicy {
 
       mGpuKernels.insert(kiter, std::make_pair(fptr, kernel));
 
-      return kernel;
+      return KernelInfo{ kernel };
     }
   }
 };
@@ -163,13 +165,18 @@ struct GpuKernelLaunchAtmiPolicy {
     return lp;
   }
 
-  static ATMIkernelHandle kernelHandle(const TaskInstance& ti) { return ti.mKernInfo; }
+  static ATMIkernelHandle kernelHandle(const TaskInstance& ti) { return ti.mKernInfo.mKern; }
 
   template <typename... Args>
   static TaskInstance makeTask(const dim3& blocks, const dim3& threadsPerBlock,
                                const KernelInfo& kinfo, Args&&... args) {
     return TaskInstance(blocks, threadsPerBlock, kinfo, std::forward<Args>(args)...);
   }
+
+  template <typename... Args>
+  static TaskInstance makeTask(const dim3& threads, const KernelInfo& kinfo, Args&&... args) {
+    return makeTask(1, threads, kinfo, std::forward<Args>(args)...);
+  }
 };
 
 using GpuExecutorAtmi =
diff --git a/cmakeUtils/addATMI.cmake b/cmakeUtils/addATMI.cmake
@@ -18,6 +18,9 @@ if(ATMI_BUILD_FROM_SRC)
   set(LLVM_DIR ${AMD_LLVM})
   # set(DEVICE_LIB_DIR ${ROCM_DEVICE_LIBS})
   set(ATMI_DEVICE_RUNTIME ON)
+  # pass through ROCm/HSA root dir to be consistent with ATMI
+  set(ROCM_DIR ${ROCM_ROOT})
+  set(ENV{GFXLIST} "${GFX_VER}")
   # invoke src/CMakeLists.txt
   add_subdirectory(${ATMI_SRC}/src ${ATMI_ROOT})
   # set variables for apps to use ATMI
diff --git a/cppUtils/include/cpputils/BitUtil.h b/cppUtils/include/cpputils/BitUtil.h
@@ -68,6 +68,19 @@ struct BitUtil {
     return res;
   }
 
+  static W getBitsByMask(const W& word, const W& mask) noexcept {
+    W res = 0;
+    unsigned idx = 0;
+    for (auto i = 0; i < NUM_BITS; ++i) {
+      if (getBit(mask, i)) {
+        W temp = getBit(word, i);
+        res = res | (temp << idx);
+        ++idx;
+      }
+    }
+    return res;
+  }
+
   static W setBitRange(const W& word, size_t lo, size_t hi) noexcept {
     checkBitRange(lo, hi);
     return (word | genMask(lo, hi));
@@ -88,6 +101,17 @@ struct BitUtil {
     return ret;
   }
 
+  static W setBitsByMask(const W& word, const W& mask) noexcept {
+    W ret = word;
+
+    for (auto i = 0; i < NUM_BITS; ++i) {
+      if (getBit(mask, i)) {
+        ret = setBit(ret, i);
+      }
+    }
+    return ret;
+  }
+
   static W clearBitRange(const W& word, size_t lo, size_t hi) noexcept {
     checkBitRange(lo, hi);
     return word & ~genMask(lo, hi);
@@ -154,6 +178,26 @@ struct BitUtil {
     return ret;
   }
 
+  static W removeBitsByMask(const W& word, const W& mask) noexcept {
+    W res = word;
+    size_t shiftAmt = 0;
+    for (auto i = 0; i < NUM_BITS; ++i) {
+      if (getBit(mask, i)) {
+        res = removeBit(res, i);
+        /*
+         * since bitIndices are sorted, removing a lower order bit changes the
+         * positions of higher order bits, so higher bitIndices are off by 1
+         * So, we left shift by 1 to make higher bitIndices valid, but ++shiftAmt to
+         * remember how many zeros we added on the right and remove them
+         */
+        res <<= 1;
+        ++shiftAmt;
+      }
+    }
+    res >>= shiftAmt; // remove the zeroes we added to adjust for higher bitIndices
+    return res;
+  }
+
   /**
    * assumes that bitIndices are sorted low to high idx
    */
@@ -197,6 +241,16 @@ struct BitUtil {
     return insertBitRange(word, idx, idx + 1);
   }
 
+  static W insertBitsByMask(const W& word, const W& mask) noexcept {
+    W ret = word;
+    for (auto i = 0; i < NUM_BITS; ++i) {
+      if (getBit(mask, i)) {
+        ret = insertBit(ret, i);
+      }
+    }
+    return ret;
+  }
+
   // This does the opposite of removeBitsByInnerBits. It uses each element of innerBitIndices to
   // capture the right set of bits from word and shift them appropriately to insert bits at
   // the right locations.
@@ -253,6 +307,19 @@ struct BitUtil {
     }
     return ret;
   }
+
+  static W replaceBitsByMask(const W& word, const W& mask, const W& newVal) noexcept {
+    W ret = word;
+    W nval = newVal;
+
+    for (auto i = 0; i < NUM_BITS; ++i) {
+      if (getBit(mask, i)) {
+        ret = replaceBit(ret, i, getLSB(nval));
+        nval >>= 1;
+      }
+    }
+    return ret;
+  }
 };
 
 template <typename T>
@@ -306,6 +373,10 @@ class BitUtil<T*> {
     return toPtr(IntBitUtil::getBits(toInt(ptr), bitIndices));
   }
 
+  static P getBitsByMask(const P& ptr, Int mask) noexcept {
+    return toPtr(IntBitUtil::getBitsByMask(toInt(ptr), mask));
+  }
+
   static P setBit(const P& ptr, size_t idx) noexcept {
     return toPtr(IntBitUtil::setBit(toInt(ptr), idx));
   }
@@ -319,6 +390,10 @@ class BitUtil<T*> {
     return toPtr(IntBitUtil::setBits(toInt(ptr), bitIndices));
   }
 
+  static P setBitsByMask(const P& ptr, Int mask) noexcept {
+    return toPtr(IntBitUtil::setBits(toInt(ptr), mask));
+  }
+
   static P clearBit(const P& ptr, size_t idx) noexcept {
     return toPtr(IntBitUtil::clearBit(toInt(ptr), idx));
   }
@@ -345,6 +420,10 @@ class BitUtil<T*> {
     return toPtr(IntBitUtil::replaceBits(toInt(ptr), bitIndices, toInt(newVal)));
   }
 
+  static P replaceBitsByMask(const P& ptr, Int mask, const P& newVal) noexcept {
+    return toPtr(IntBitUtil::replaceBitsByMask(toInt(ptr), mask, toInt(newVal)));
+  }
+
   static P removeBit(const P& ptr, size_t idx) noexcept {
     return toPtr(IntBitUtil::removeBit(toInt(ptr), idx));
   }
@@ -357,6 +436,10 @@ class BitUtil<T*> {
   static P removeBits(const P& ptr, const V& bitIndices) noexcept {
     return toPtr(IntBitUtil::removeBits(toInt(ptr), bitIndices));
   }
+  
+  static P removeBitsByMask(const P& ptr, Int mask) noexcept {
+    return toPtr(IntBitUtil::removeBitsByMask(toInt(ptr), mask));
+  }
 
   template <typename V>
   static P removeBitsByInnerBits(const P& ptr, const V& innerBitIndices) noexcept {
@@ -376,6 +459,10 @@ class BitUtil<T*> {
     return toPtr(IntBitUtil::insertBits(toInt(ptr), bitIndices));
   }
 
+  static P insertBitsByMask(const P& ptr, Int mask) noexcept {
+    return toPtr(IntBitUtil::insertBitsByMask(toInt(ptr), mask));
+  }
+
   template <typename V>
   static P insertBitsByInnerBits(const P& ptr, const V& innerBitIndices) noexcept {
     return toPtr(IntBitUtil::insertBitsByInnerBits(toInt(ptr), innerBitIndices));
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -4,6 +4,10 @@ function(addDageeTarget EXE_NAME SRC_NAME)
   add_executable(${EXE_NAME} ${SRC_NAME})
   buildWithATMI(${EXE_NAME})
   add_test(${EXE_NAME} ${EXE_NAME})
+  # FIXME TODO(ashwin): disable SDMA because there seems to be a bug specifically
+  # with device-to-host copies (for certain buffer sizes). Remove the below line
+  # when the bug gets fixed.
+  set_tests_properties(${EXE_NAME} PROPERTIES ENVIRONMENT HSA_ENABLE_SDMA=0)
 endfunction()
 
 addDageeTarget(kiteDagSimple kiteDagSimple.cpp)
diff --git a/examples/kiteDagMixed.cpp b/examples/kiteDagMixed.cpp
@@ -57,6 +57,7 @@ void checkOutput(const V& A) {
     std::cout << "OK. Output check passed" << std::endl;
   } else {
     std::cerr << "ERROR. Output check failed" << std::endl;
+    std::abort();
   }
 }
 
diff --git a/examples/kiteDagMixedNoAuto.cpp b/examples/kiteDagMixedNoAuto.cpp
@@ -57,6 +57,7 @@ void checkOutput(const V& A) {
     std::cout << "OK. Output check passed" << std::endl;
   } else {
     std::cerr << "ERROR. Output check failed" << std::endl;
+    std::abort();
   }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -57,6 +57,7 @@ void checkOutput(const V& A) {`
`57`	`57`	`std::cout << "OK. Output check passed" << std::endl;`
`58`	`58`	`} else {`
`59`	`59`	`std::cerr << "ERROR. Output check failed" << std::endl;`
	`60`	`+ std::abort();`
`60`	`61`	`}`
`61`	`62`	`}`
`62`	`63`