[SYCL] Enable useful (not random) output from stream

Pool of flush buffers is allocated in local memory. This pool contains
space for each work item in the work group. Each work item writes to
its own space (flush buffer), as a result output from different work
items is not mixed. Data is flushed to global buffer on endl, flush or
when kernel execution is finished.  Global buffer contains all output
from the kernel. Offset of the WI's flush buffer in the pool is
calculated only once in __init method. Call to this method is generated
by frontend.

In the current implementation user should explicitly flush data on the
host device. Data is not flushed automatically after kernel execution
because of the missing feature in the scheduler.

Signed-off-by: Artur Gainullin <[email protected]>

Author: againull

clang/lib/Sema/SemaSYCL.cpp

@@ -63,6 +63,10 @@ class Util {
   /// sampler class.
   static bool isSyclSamplerType(const QualType &Ty);
 
+  /// Checks whether given clang type is a full specialization of the SYCL
+  /// stream class.
+  static bool isSyclStreamType(const QualType &Ty);
+
   /// Checks whether given clang type is a standard SYCL API class with given
   /// name.
   /// \param Ty    the clang type being checked
@@ -784,7 +788,7 @@ static CompoundStmt *CreateOpenCLKernelBody(Sema &S,
         // All special SYCL objects must have __init method
         CXXMethodDecl *InitMethod = getInitMethod(CRD);
         assert(InitMethod &&
-               "The accessor/sampler must have the __init method");
+               "The accessor/sampler/stream must have the __init method");
         unsigned NumParams = InitMethod->getNumParams();
         llvm::SmallVector<Expr *, 4> ParamDREs(NumParams);
         auto KFP = KernelFuncParam;
@@ -794,7 +798,9 @@ static CompoundStmt *CreateOpenCLKernelBody(Sema &S,
               S.Context, NestedNameSpecifierLoc(), SourceLocation(), *KFP,
               false, DeclarationNameInfo(), ParamType, VK_LValue);
         }
-        std::advance(KernelFuncParam, NumParams - 1);
+
+        if (NumParams)
+          std::advance(KernelFuncParam, NumParams - 1);
 
         DeclAccessPair FieldDAP = DeclAccessPair::make(Field, AS_none);
         // [kernel_obj or wrapper object].special_obj
@@ -923,6 +929,11 @@ static CompoundStmt *CreateOpenCLKernelBody(Sema &S,
               DeclarationNameInfo(Field->getDeclName(), SourceLocation()),
               nullptr, Field->getType(), VK_LValue, OK_Ordinary, NOUR_None);
           getExprForWrappedAccessorInit(CRD, Lhs);
+          if (Util::isSyclStreamType(FieldType)) {
+            // Generate call to the __init method of the stream class after
+            // initializing accessors wrapped by this stream object
+            getExprForSpecialSYCLObj(FieldType, Field, CRD, KernelObjCloneRef);
+          }
         }
       } else {
         llvm_unreachable("Unsupported field type");
@@ -1732,6 +1743,10 @@ bool Util::isSyclSamplerType(const QualType &Ty) {
   return isSyclType(Ty, "sampler");
 }
 
+bool Util::isSyclStreamType(const QualType &Ty) {
+  return isSyclType(Ty, "stream");
+}
+
 bool Util::isSyclType(const QualType &Ty, StringRef Name, bool Tmpl) {
   Decl::Kind ClassDeclKind =
       Tmpl ? Decl::Kind::ClassTemplateSpecialization : Decl::Kind::CXXRecord;

sycl/include/CL/sycl/accessor.hpp

@@ -1111,26 +1111,26 @@ class accessor<DataT, Dimensions, AccessMode, access::target::local,
     return getQualifiedPtr()[Index];
   }
 
-  template <int Dims = Dimensions,
-            typename = detail::enable_if_t<Dims == 0 &&
-                                           AccessMode == access::mode::atomic>>
-  operator atomic<DataT, AS>() const {
+  template <int Dims = Dimensions>
+  operator typename detail::enable_if_t<
+      Dims == 0 && AccessMode == access::mode::atomic, atomic<DataT, AS>>()
+      const {
     return atomic<DataT, AS>(multi_ptr<DataT, AS>(getQualifiedPtr()));
   }
 
-  template <int Dims = Dimensions,
-            typename = detail::enable_if_t<(Dims > 0) &&
-                                           AccessMode == access::mode::atomic>>
-  atomic<DataT, AS> operator[](id<Dimensions> Index) const {
+  template <int Dims = Dimensions>
+  typename detail::enable_if_t<(Dims > 0) && AccessMode == access::mode::atomic,
+                               atomic<DataT, AS>>
+  operator[](id<Dimensions> Index) const {
     const size_t LinearIndex = getLinearIndex(Index);
     return atomic<DataT, AS>(
         multi_ptr<DataT, AS>(getQualifiedPtr() + LinearIndex));
   }
 
-  template <int Dims = Dimensions,
-            typename = detail::enable_if_t<Dims == 1 &&
-                                           AccessMode == access::mode::atomic>>
-  atomic<DataT, AS> operator[](size_t Index) const {
+  template <int Dims = Dimensions>
+  typename detail::enable_if_t<Dims == 1 && AccessMode == access::mode::atomic,
+                               atomic<DataT, AS>>
+  operator[](size_t Index) const {
     return atomic<DataT, AS>(multi_ptr<DataT, AS>(getQualifiedPtr() + Index));
   }
 

sycl/include/CL/sycl/detail/accessor_impl.hpp

@@ -141,6 +141,23 @@ class LocalAccessorImplHost {
   int MDims;
   int MElemSize;
   std::vector<char> MMem;
+
+  bool PerWI = false;
+  size_t LocalMemSize;
+  size_t MaxWGSize;
+  void resize(size_t LocalSize, size_t GlobalSize) {
+    if (GlobalSize != 1 && LocalSize != 1) {
+      // If local size is not specified then work group size is chosen by
+      // runtime. That is why try to allocate based on max work group size or
+      // global size. In the worst case allocate 80% of local memory.
+      size_t MinEstWGSize = LocalSize ? LocalSize : GlobalSize;
+      MinEstWGSize = MinEstWGSize > MaxWGSize ? MaxWGSize : MinEstWGSize;
+      size_t NewSize = MinEstWGSize * MSize[0];
+      MSize[0] =
+          NewSize > 8 * LocalMemSize / 10 ? 8 * LocalMemSize / 10 : NewSize;
+      MMem.resize(NewSize * MElemSize);
+    }
+  }
 };
 
 class LocalAccessorBaseHost {