Fix errors in histogram example (oneapi-src#1011)

* Fix errors in histogram example

* Copy example 1:1 from https://github.com/oneapi-src/oneDPL/tree/main/examples/histogram

Author: SergeyKopienko

DirectProgramming/DPC++/ParallelPatterns/histogram/src/main.cpp

@@ -4,16 +4,14 @@
 // SPDX-License-Identifier: MIT
 // =============================================================
 
-#include <oneapi/dpl/execution>
+// oneDPL headers should be included before standard headers
 #include <oneapi/dpl/algorithm>
+#include <oneapi/dpl/execution>
 #include <oneapi/dpl/numeric>
+
 #include <CL/sycl.hpp>
-#include <random>
 #include <iostream>
-
-// dpc_common.hpp can be found in the dev-utilities include folder.
-// e.g., $ONEAPI_ROOT/dev-utilities//include/dpc_common.hpp
-#include "dpc_common.hpp"
+#include <random>
 
 // Dense algorithm stores all the bins, even if bin has 0 entries
 // input array [4,4,1,0,1,2]
@@ -24,8 +22,7 @@
 
 void dense_histogram(std::vector<uint64_t> &input) {
   const int N = input.size();
-  cl::sycl::buffer<uint64_t, 1> histogram_buf{input.data(),
-                                              cl::sycl::range<1>(N)};
+  sycl::buffer<uint64_t> histogram_buf{input.data(), sycl::range<1>(N)};
 
   // Combine the equal values together
   std::sort(oneapi::dpl::execution::dpcpp_default,
@@ -37,8 +34,7 @@ void dense_histogram(std::vector<uint64_t> &input) {
     sycl::host_accessor histogram(histogram_buf, sycl::read_only);
     num_bins = histogram[N - 1] + 1;
   }
-  cl::sycl::buffer<uint64_t, 1> histogram_new_buf{cl::sycl::range<1>(num_bins)};
-  cl::sycl::buffer<uint64_t, 1> bins{cl::sycl::range<1>(num_bins)};
+  sycl::buffer<uint64_t> histogram_new_buf{sycl::range<1>(num_bins)};
   auto val_begin = oneapi::dpl::counting_iterator<int>{0};
 
   // Determine the end of each bin of value
@@ -51,11 +47,11 @@ void dense_histogram(std::vector<uint64_t> &input) {
   std::adjacent_difference(oneapi::dpl::execution::dpcpp_default,
                            oneapi::dpl::begin(histogram_new_buf),
                            oneapi::dpl::end(histogram_new_buf),
-                           oneapi::dpl::begin(bins));
+                           oneapi::dpl::begin(histogram_new_buf));
 
-  std::cout << "Dense Histogram:\n";
+  std::cout << "success for Dense Histogram:\n";
   {
-    sycl::host_accessor histogram_new(bins, sycl::read_only);
+    sycl::host_accessor histogram_new(histogram_new_buf, sycl::read_only);
     std::cout << "[";
     for (int i = 0; i < num_bins; i++) {
       std::cout << "(" << i << ", " << histogram_new[i] << ") ";
@@ -66,64 +62,60 @@ void dense_histogram(std::vector<uint64_t> &input) {
 
 void sparse_histogram(std::vector<uint64_t> &input) {
   const int N = input.size();
-  cl::sycl::buffer<uint64_t, 1> histogram_buf{input.data(),
-                                              cl::sycl::range<1>(N)};
+  sycl::buffer<uint64_t> histogram_buf{input.data(), sycl::range<1>(N)};
 
   // Combine the equal values together
   std::sort(oneapi::dpl::execution::dpcpp_default,
             oneapi::dpl::begin(histogram_buf), oneapi::dpl::end(histogram_buf));
 
-  auto num_bins = std::transform_reduce(
-      oneapi::dpl::execution::dpcpp_default, oneapi::dpl::begin(histogram_buf),
-      oneapi::dpl::end(histogram_buf) - 1, oneapi::dpl::begin(histogram_buf) + 1, 1,
-      std::plus<int>(), std::not_equal_to<int>());
-
-  // Create new buffer to store the unique values and their count
-  cl::sycl::buffer<uint64_t, 1> histogram_values_buf{
-      cl::sycl::range<1>(num_bins)};
-  cl::sycl::buffer<uint64_t, 1> histogram_counts_buf{
-      cl::sycl::range<1>(num_bins)};
+  // Create new buffer to store the unique valuesand their count;
+  // oneapi::dpl::reduce_by_segment requires a sufficient buffer size(for worst case).
+  // TODO: To consider usage of just 'sort' and 'transform_reduce' for calculate
+  // a final result.There is a guess that such approach is more effective.
+  sycl::buffer<uint64_t> histogram_values_buf{sycl::range<1>(N)};
+  sycl::buffer<uint64_t> histogram_counts_buf{sycl::range<1>(N)};
 
-  cl::sycl::buffer<uint64_t, 1> _const_buf{cl::sycl::range<1>(N)};
+  sycl::buffer<uint64_t> _const_buf{sycl::range<1>(N)};
   std::fill(oneapi::dpl::execution::dpcpp_default,
             oneapi::dpl::begin(_const_buf), oneapi::dpl::end(_const_buf), 1);
 
+  auto histogram_values_buf_begin = oneapi::dpl::begin(histogram_values_buf);
+  auto histogram_counts_buf_begin = oneapi::dpl::begin(histogram_counts_buf);
+
   // Find the count of each value
-  oneapi::dpl::reduce_by_segment(
+  const auto result = oneapi::dpl::reduce_by_segment(
       oneapi::dpl::execution::dpcpp_default, oneapi::dpl::begin(histogram_buf),
       oneapi::dpl::end(histogram_buf), oneapi::dpl::begin(_const_buf),
-      oneapi::dpl::begin(histogram_values_buf),
-      oneapi::dpl::begin(histogram_counts_buf));
+      histogram_values_buf_begin,
+      histogram_counts_buf_begin);
+
+  const auto num_bins = result.first - histogram_values_buf_begin;
+  assert(num_bins == result.second - histogram_counts_buf_begin);
 
-  std::cout << "Sparse Histogram:\n";
+  std::cout << "success for Sparse Histogram:\n";
+  sycl::host_accessor histogram_value(histogram_values_buf, sycl::read_only);
+  sycl::host_accessor histogram_count(histogram_counts_buf, sycl::read_only);
   std::cout << "[";
   for (int i = 0; i < num_bins; i++) {
-    sycl::host_accessor histogram_value(histogram_values_buf, sycl::read_only);
-    sycl::host_accessor histogram_count(histogram_counts_buf, sycl::read_only);
-    std::cout << "(" << histogram_value[i] << ", " << histogram_count[i]
-              << ") ";
+      std::cout << "(" << histogram_value[i] << ", " << histogram_count[i]
+                << ") ";
   }
   std::cout << "]\n";
 }
 
 int main(void) {
   const int N = 1000;
-  std::vector<uint64_t> input, dense, sparse;
+  std::vector<uint64_t> input;
   srand((unsigned)time(0));
   // initialize the input array with randomly generated values between 0 and 9
   for (int i = 0; i < N; i++) input.push_back(rand() % 9);
 
   // replacing all input entries of "4" with random number between 1 and 3
-  // this is to ensure that we have atleast one entry with zero-bin size,
+  // this is to ensure that we have at least one entry with zero-bin size,
   // which shows the difference between sparse and dense algorithm output
   for (int i = 0; i < N; i++)
     if (input[i] == 4) input[i] = rand() % 3;
-  std::cout << "Input:\n";
-  for (int i = 0; i < N; i++) std::cout << input[i] << " ";
-  std::cout << "\n";
-  dense = input;
-  dense_histogram(dense);
-  sparse = input;
-  sparse_histogram(sparse);
+  dense_histogram(input);
+  sparse_histogram(input);
   return 0;
 }