Index: ETSN/MySteps_6_SyCL.cpp
===================================================================
--- ETSN/MySteps_6_SyCL.cpp	(revision 0)
+++ ETSN/MySteps_6_SyCL.cpp	(revision 310)
@@ -0,0 +1,150 @@
+// To create and activate compete SyCL environment, Debian Bookworm
+// Create...
+// export DPCPP_HOME=$PWD/sycl_workspace
+// mv $DPCPP_HOME ${DPCPP_HOME}-$(date "+%Y%m%d-%H%M")
+// mkdir $DPCPP_HOME
+// cd $DPCPP_HOME
+// git clone https://github.com/intel/llvm -b sycl
+// python3 $DPCPP_HOME/llvm/buildbot/configure.py --cuda
+// python3 $DPCPP_HOME/llvm/buildbot/compile.py
+// python3 $DPCPP_HOME/llvm/buildbot/check.py
+// Use...
+// export PATH=$DPCPP_HOME/llvm/build/bin:$PATH
+// export LD_LIBRARY_PATH=$DPCPP_HOME/llvm/build/lib:$LD_LIBRARY_PATH
+// clang++ -fsycl -fsycl-targets=nvptx64-nvidia-cuda -DCHECK MySteps_sycl.cpp -o MySteps_sycl.exe -lm
+// ./MySteps_sycl.exe 1024 10
+
+#include <iostream>
+#include <sycl/sycl.hpp>
+#include <math.h>
+#include <sys/time.h>
+
+#define MYFLOAT float
+
+#define ERROR 1e-5
+
+MYFLOAT MySillyFunction(MYFLOAT x)
+{
+    return(pow(sqrt(log(exp(atanh(tanh(asinh(sinh(acosh(cosh(atan(tan(asin(sin(acos(cos(x))))))))))))))),2));
+}
+
+void MySillySum(MYFLOAT *res, MYFLOAT *a, MYFLOAT *b,int calls, int size)
+{
+  for (uint i=0; i<size;i++) 
+    {
+      MYFLOAT ai=a[i];
+      MYFLOAT bi=b[i];
+      
+      for (int c=0;c<calls;c++)
+        {
+          ai=MySillyFunction(ai);
+          bi=MySillyFunction(bi);
+        }
+
+      res[i] = ai + bi;
+    }
+}
+
+using namespace std;
+int main(int argc, char *argv[]) {
+  MYFLOAT *a,*b,*res,*resacc;
+  int size=1024;
+  int calls=1;
+  struct timeval tv1,tv2;
+ 
+  if (argc > 1) {
+    size=(int)atoll(argv[1]);
+    calls=(int)atoll(argv[2]);
+  }
+  else {
+    printf("\n\tMySteps : Estimate SillySum\n\n\t\t#1 : size (default 1024)\n\t\t#2 : calls (default 1)\n\n");
+  }
+
+  std::cout << size << " " << calls << std::endl ;
+
+  a=(MYFLOAT*)malloc(size*sizeof(MYFLOAT));
+  b=(MYFLOAT*)malloc(size*sizeof(MYFLOAT));
+  res=(MYFLOAT*)malloc(size*sizeof(MYFLOAT));
+  resacc=(MYFLOAT*)malloc(size*sizeof(MYFLOAT));
+
+  srand(110271);
+  // Initialize the vectors
+  for (size_t I = 0; I < size; ++I) {
+    a[I]=(MYFLOAT)rand()/(MYFLOAT)RAND_MAX;
+    b[I]=(MYFLOAT)rand()/(MYFLOAT)RAND_MAX;
+    res[I]=0;
+  }
+
+#ifdef CHECK
+  gettimeofday(&tv1, NULL);
+  MySillySum(res,a,b,calls,size);
+  gettimeofday(&tv2, NULL);
+  MYFLOAT elapsedNative=(MYFLOAT)((tv2.tv_sec-tv1.tv_sec) * 1000000L +
+                                  (tv2.tv_usec-tv1.tv_usec))/1000000;
+
+  std::cout << "ElapsedNative: " << elapsedNative << std::endl;
+  std::cout << "NativeRate: " << size/elapsedNative << std::endl;
+#endif
+  
+  gettimeofday(&tv1, NULL);
+  
+  sycl::buffer<MYFLOAT> aBuf(&a[0],size);
+  sycl::buffer<MYFLOAT> bBuf(&b[0],size);
+  sycl::buffer<MYFLOAT> resaccBuf(&resacc[0],size);
+
+  // Creating SYCL queue
+  sycl::queue Queue;
+
+  Queue.submit([&](auto &h) {
+    // Getting write only access to the buffer on a device.
+    sycl::accessor Aa{aBuf, h, sycl::read_only};
+    sycl::accessor Ab{bBuf, h, sycl::read_only};
+    sycl::accessor Aresacc{resaccBuf, h};
+    
+    // Executing kernel
+    h.parallel_for(size,[=](auto i) {      
+      MYFLOAT Aai = Aa[i];
+      MYFLOAT Abi = Ab[i] ;
+      for (size_t C = 0 ; C < calls ; C++) {
+        Aai = MySillyFunction(Aai);
+        Abi = MySillyFunction(Abi) ;
+      }
+      Aresacc[i] = Aai + Abi ;
+    });
+  });
+
+  // Getting read only access to the buffer on the host.
+  // Implicit barrier waiting for queue to complete the work.
+  sycl::host_accessor HostAccessor{resaccBuf};
+
+  gettimeofday(&tv2, NULL);
+
+  MYFLOAT elapsedSyCL=(MYFLOAT)((tv2.tv_sec-tv1.tv_sec) * 1000000L +
+                                  (tv2.tv_usec-tv1.tv_usec))/1000000;
+
+  // Check the results
+#ifdef CHECK
+  bool MismatchFound = false;
+  for (size_t I = 0; I < size; ++I) {
+    if ( fabs(resacc[I] - res[I]) > ERROR ) {
+      std::cout << "Element: " << I << ", error: " << res[I]-resacc[I]
+                << std::endl;
+      MismatchFound = true;
+    }
+  }
+
+  if (!MismatchFound) {
+    std::cout << "The results are correct!" << std::endl;
+  }
+  // return MismatchFound;
+#endif
+ 
+  std::cout << "ElapsedSyCL: " << elapsedSyCL << ::std::endl;
+  std::cout << "SyCLRate: " << size/elapsedSyCL << std::endl;
+  
+  free(a);
+  free(b);
+  free(res);
+  free(resacc);
+
+}
