printf implementation with high-level interfaces

The original printf implementation used cm::svm interfaces the could
only be translated into legacy messages. cm::atomic::execute interface
and dereferencing are utilized in printf implementation now to generate
IR that can be translated into both legacy and LSC messages.
Legacy cm::svm interfaces were removed.

Author: dmitryryintel

IGC/VectorCompiler/CMCL/lib/Headers/cm-cl/detail/builtins.h

@@ -56,17 +56,6 @@ int __cm_cl_printf_format_index(__global const char *str);
 //        switch to using addrspaces.
 int __cm_cl_printf_format_index(__private const char *str);
 
-// SVM memory operations have only 64 bit addressing. One can extend the address
-// or use statefull operations for 32 bit addressing.
-template <typename T, int width>
-void __cm_cl_svm_scatter(int num_blocks, vector_impl<uint64_t, width> address,
-                         vector_impl<T, width> src);
-
-template <typename T, int width>
-vector_impl<T, width>
-__cm_cl_svm_atomic_add(vector_impl<uint64_t, width> address,
-                       vector_impl<T, width> src);
-
 uint32_t __cm_cl_lzd(uint32_t src);
 template <int width>
 vector_impl<uint32_t, width> __cm_cl_lzd(vector_impl<uint32_t, width> src);
@@ -239,22 +228,6 @@ inline int printf_format_index(__private const char *str) {
   return __cm_cl_printf_format_index(str);
 }
 
-template <int num_blocks, typename T, int width>
-void svm_scatter(vector_impl<uint64_t, width> address,
-                 vector_impl<T, num_blocks * width> src) {
-  static_assert(sizeof(T) == 1 || sizeof(T) == 4 || sizeof(T) == 8,
-                "invalid type");
-  constexpr auto lowered_num_blocks = encode_num_blocks(num_blocks);
-  static_assert(lowered_num_blocks >= 0, "invalid number of blocks");
-  __cm_cl_svm_scatter(lowered_num_blocks, address, src);
-}
-
-template <typename T, int width>
-vector_impl<T, width> svm_atomic_add(vector_impl<uint64_t, width> address,
-                                     vector_impl<T, width> src) {
-  return __cm_cl_svm_atomic_add(address, src);
-}
-
 inline uint32_t lzd(uint32_t src) { return __cm_cl_lzd(src); }
 
 template <int width>

IGC/VectorCompiler/CMCL/lib/Headers/cm-cl/svm.h

@@ -149,50 +149,6 @@
         ]
       }
     },
-    "SVMScatter": {
-      "Name": "svm_scatter",
-      "Operands": [
-        {"Name": "NumBlocks", "Kind": "Constant"},
-        {"Name": "Address", "Kind": "Input"},
-        {"Name": "Source", "Kind": "Input"}
-      ],
-      "TranslateInto": {
-        "VC-Intrinsic": "genx_svm_scatter",
-        "ReturnType": {"GetBuiltinReturnType": []},
-        "Operands": [
-          {"Code": [
-            "*IRB.CreateVectorSplat(getVectorWidth({}), IRB.getTrue())",
-            {"GetBuiltinOperandType": ["Address"]}
-          ]},
-          {"GetBuiltinOperand": ["NumBlocks"]},
-          {"GetBuiltinOperand": ["Address"]},
-          {"GetBuiltinOperand": ["Source"]}
-        ]
-      }
-    },
-    "SVMAtomicAdd": {
-      "Name": "svm_atomic_add",
-      "Operands": [
-        {"Name": "Address", "Kind": "Input"},
-        {"Name": "Source", "Kind": "Input"}
-      ],
-      "TranslateInto": {
-        "VC-Intrinsic": "genx_svm_atomic_add",
-        "ReturnType": {"GetBuiltinReturnType": []},
-        "Operands": [
-          {"Code": [
-            "*IRB.CreateVectorSplat(getVectorWidth({}), IRB.getTrue())",
-            {"GetBuiltinOperandType": ["Address"]}
-          ]},
-          {"GetBuiltinOperand": ["Address"]},
-          {"GetBuiltinOperand": ["Source"]},
-          {"Code": [
-            "*UndefValue::get(&{})",
-            {"GetBuiltinOperandType": ["Source"]}
-          ]}
-        ]
-      }
-    },
     "LZD": {
       "Name": "lzd",
       "Operands": [

IGC/VectorCompiler/CMCL/lib/Support/TranslationDescription.json

@@ -9,7 +9,7 @@ SPDX-License-Identifier: MIT
 #ifndef VC_BIF_PRINTF_NOT_CM_COMMON_H
 #define VC_BIF_PRINTF_NOT_CM_COMMON_H
 
-#include <cm-cl/svm.h>
+#include <cm-cl/atomic.h>
 #include <cm-cl/vector.h>
 #include <opencl_def.h>
 
@@ -56,48 +56,53 @@ inline int calcRequiredBufferSize(vector<int, ArgsInfoVector::Size> ArgsInfo) {
   return BufferSize;
 }
 
-static inline BufferElementTy getInitialBufferOffset(uintptr_t BufferPtr,
-                                                     int RequiredSize) {
-  constexpr int MagicNumber = 8;
-  constexpr cl_vector<uint64_t, MagicNumber> AddrOffset{0,  4,  8,  12,
-                                                        16, 20, 24, 28};
-  vector<BufferElementTy, MagicNumber> Result;
-  vector<BufferElementTy, MagicNumber> Size = 0;
-  Size[0] = RequiredSize;
-  vector<uint64_t, MagicNumber> Offsets(AddrOffset);
-  vector<uintptr_t, MagicNumber> Addr = BufferPtr + Offsets;
-
-  Result = svm::atomic<atomic::operation::add>(Addr, Size);
-  return Result[0];
+// Return initial buffer offset in BufferElementTy elements (not in bytes).
+static inline BufferElementTy
+getInitialBufferOffset(__global BufferElementTy *BufferPtr,
+                       BufferElementTy RequiredSize) {
+#if __clang_major__ > 9
+  int ByteOffset =
+      atomic::execute<atomic::operation::add, memory_order_relaxed,
+                      memory_scope_all_devices>(BufferPtr, RequiredSize);
+#else  // __clang_major__ > 9
+  // Helping clang-9 correctly deduce the argument type.
+  int ByteOffset =
+      atomic::execute<atomic::operation::add, memory_order_relaxed,
+                      memory_scope_all_devices, __global BufferElementTy>(
+          BufferPtr, RequiredSize);
+#endif // __clang_major__ > 9
+  return ByteOffset / sizeof(BufferElementTy);
 }
 
-static inline vector<BufferElementTy, AddressVectorWidth>
-castPointerToVector(uintptr_t Ptr) {
-  vector<uint64_t, 1> Tmp = Ptr;
+template <typename T>
+static vector<BufferElementTy, AddressVectorWidth> castPointerToVector(T *Ptr) {
+  vector<uint64_t, 1> Tmp = reinterpret_cast<uintptr_t>(Ptr);
   return Tmp.format<BufferElementTy>();
 }
 
 // A helper function to properly set CurAddressLow and CurAddressHigh
 // elements of \p TransferData vector by the provided \p Ptr.
 static inline void
 setCurAddress(vector<BufferElementTy, TransferDataSize> &TransferData,
-              uintptr_t Ptr) {
+              __global BufferElementTy *Ptr) {
   TransferData.select<AddressVectorWidth, 1>(
       TransferDataLayout::CurAddressLow) = castPointerToVector(Ptr);
 }
 
 // A helper function to properly extract current address from \p TransferData.
-static inline uintptr_t
+static inline __global BufferElementTy *
 getCurAddress(vector<BufferElementTy, TransferDataSize> TransferData) {
   vector<BufferElementTy, AddressVectorWidth> Address =
       TransferData.select<AddressVectorWidth, 1>(
           TransferDataLayout::CurAddressLow);
   // Bit-casting to 64-bit int and then truncating if necessary.
-  return Address.format<uint64_t>();
+  return reinterpret_cast<__global BufferElementTy *>(
+      static_cast<uintptr_t>(Address.format<uint64_t>()));
 }
 
 static inline vector<BufferElementTy, TransferDataSize>
-generateTransferData(uintptr_t InitPtr, BufferElementTy ReturnValue) {
+generateTransferData(__global BufferElementTy *InitPtr,
+                     BufferElementTy ReturnValue) {
   vector<BufferElementTy, TransferDataSize> TransferData;
   setCurAddress(TransferData, InitPtr);
   TransferData[TransferDataLayout::ReturnValue] = ReturnValue;
@@ -111,21 +116,27 @@ vector<BufferElementTy, TransferDataSize>
 printf_init_impl(vector<int, ArgsInfoVector::Size> ArgsInfo) {
   auto FmtStrSize = ArgsInfo[ArgsInfoVector::FormatStrSize];
   if (FmtStrSize > MaxFormatStrSize)
-    return generateTransferData(/* BufferPtr */ 0, /* ReturnValue */ -1);
+    return generateTransferData(/* BufferPtr */ nullptr, /* ReturnValue */ -1);
   auto BufferSize = calcRequiredBufferSize<StringAnnotationSize>(ArgsInfo);
-  auto BufferPtr = reinterpret_cast<uintptr_t>(cm::detail::printf_buffer());
+#if __clang_major__ > 9
+  auto *BufferPtr =
+      static_cast<__global BufferElementTy *>(cm::detail::printf_buffer());
+#else  // __clang_major__ > 9
+  // clang-9 cannot handle this auto.
+  __global BufferElementTy *BufferPtr =
+      static_cast<__global BufferElementTy *>(cm::detail::printf_buffer());
+#endif // __clang_major__ > 9
   auto Offset = getInitialBufferOffset(BufferPtr, BufferSize);
   return generateTransferData(BufferPtr + Offset, /* ReturnValue */ 0);
 }
 
 // Writes \p Data to printf buffer via \p CurAddress pointer.
 // Returns promoted pointer.
-static inline uintptr_t writeElementToBuffer(uintptr_t CurAddress,
-                                             BufferElementTy Data) {
-  vector<uintptr_t, 1> CurAddressVec = CurAddress;
-  vector<BufferElementTy, 1> DataVec = Data;
-  svm::scatter(CurAddressVec, DataVec);
-  return CurAddress + sizeof(Data);
+static inline __global BufferElementTy *
+writeElementToBuffer(__global BufferElementTy *CurAddress,
+                     BufferElementTy Data) {
+  *CurAddress = Data;
+  return ++CurAddress;
 }
 
 // ArgCode is written into printf buffer before every argument.
@@ -189,7 +200,7 @@ printf_arg_impl(vector<BufferElementTy, TransferDataSize> TransferData,
     // Just skip.
     return TransferData;
   vector<BufferElementTy, ArgInfo::Size> Info = getArgInfo<StringArgSize>(Kind);
-  uintptr_t CurAddress = getCurAddress(TransferData);
+  __global BufferElementTy *CurAddress = getCurAddress(TransferData);
   CurAddress = writeElementToBuffer(CurAddress, Info[ArgInfo::Code]);
   for (int Idx = 0; Idx != Info[ArgInfo::NumDWords]; ++Idx)
     CurAddress = writeElementToBuffer(CurAddress, Arg[Idx]);

IGC/VectorCompiler/lib/BiF/printf_not_cm_common.h

@@ -28,7 +28,7 @@ printf_fmt_impl(vector<BufferElementTy, TransferDataSize> TransferData,
   if (TransferData[TransferDataLayout::ReturnValue])
     // Just skip.
     return TransferData;
-  uintptr_t CurAddress = getCurAddress(TransferData);
+  __global BufferElementTy *CurAddress = getCurAddress(TransferData);
   BufferElementTy Index = detail::printf_format_index(FormatString);
   CurAddress = writeElementToBuffer(CurAddress, Index);
   setCurAddress(TransferData, CurAddress);
@@ -49,7 +49,7 @@ printf_arg_str_impl(vector<BufferElementTy, TransferDataSize> TransferData,
   if (TransferData[TransferDataLayout::ReturnValue])
     // Just skip.
     return TransferData;
-  uintptr_t CurAddress = getCurAddress(TransferData);
+  __global BufferElementTy *CurAddress = getCurAddress(TransferData);
   BufferElementTy Index = detail::printf_format_index(String);
   CurAddress = writeElementToBuffer(CurAddress, ArgCode::String);
   CurAddress = writeElementToBuffer(CurAddress, Index);

IGC/VectorCompiler/lib/BiF/printf_ocl_genx.cpp

@@ -28,9 +28,8 @@ printf_fmt_impl(vector<BufferElementTy, TransferDataSize> TransferData,
   if (TransferData[TransferDataLayout::ReturnValue])
     // Just skip.
     return TransferData;
-  uintptr_t CurAddress = getCurAddress(TransferData);
-  auto StrAddress =
-      castPointerToVector(reinterpret_cast<uintptr_t>(FormatString));
+  __global BufferElementTy *CurAddress = getCurAddress(TransferData);
+  auto StrAddress = castPointerToVector(FormatString);
   for (int Idx = 0; Idx != StringDWordSize; ++Idx)
     CurAddress = writeElementToBuffer(CurAddress, StrAddress[Idx]);
   setCurAddress(TransferData, CurAddress);
@@ -43,9 +42,8 @@ template <typename T>
 vector<BufferElementTy, TransferDataSize>
 printf_arg_str_impl(vector<BufferElementTy, TransferDataSize> TransferData,
                     T *String) {
-  return printf_arg_impl<StringDWordSize>(
-      TransferData, ArgKind::String,
-      castPointerToVector(reinterpret_cast<uintptr_t>(String)));
+  return printf_arg_impl<StringDWordSize>(TransferData, ArgKind::String,
+                                          castPointerToVector(String));
 }
 
 extern "C" cl_vector<BufferElementTy, TransferDataSize>