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

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
@@ -770,7 +774,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;
@@ -780,7 +784,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
@@ -909,6 +915,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");
@@ -1714,6 +1725,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 {