clang-format fix

Author: olegkkruglov

cpp/oneapi/dal/backend/primitives/frontier/advance.hpp

@@ -44,7 +44,9 @@ struct frontier_context_state {
 template <typename InFrontierDevT, typename OutFrontierDevT>
 class frontier_context {
 public:
-    frontier_context(std::uint64_t limit, InFrontierDevT in_dev_frontier, OutFrontierDevT out_dev_frontier)
+    frontier_context(std::uint64_t limit,
+                     InFrontierDevT in_dev_frontier,
+                     OutFrontierDevT out_dev_frontier)
             : limit(limit),
               in_dev_frontier(in_dev_frontier),
               out_dev_frontier(out_dev_frontier) {}
@@ -327,17 +329,50 @@ sycl::event advance(const GraphT& graph,
 
     auto e = q.submit([&](sycl::handler& cgh) {
         cgh.depends_on(to_wait);
-        sycl::local_accessor<uint32_t, 1> n_edges_wg{local_range, cgh}; // number of edges of vertices to process at work-group granularity
-        sycl::local_accessor<uint32_t, 1> n_edges_sg{local_range, cgh}; // number of edges of vertices to process at sub-group granularity
-        sycl::local_accessor<bool, 1> visited{local_range, cgh}; // tracks the vertices already visited at work-group and sub-group granularity
-        sycl::local_accessor<element_t, 1> subgroup_reduce{local_range, cgh}; // stores the vertices to process at sub-group granularity
-        sycl::local_accessor<uint32_t, 1> subgroup_reduce_tail{max_num_subgroups, cgh}; // stores the tail of the subgroup reduction
-        sycl::local_accessor<uint32_t, 1> subgroup_ids{local_range, cgh}; // stores the thread id that found the vertex to process at sub-group level
-        sycl::local_accessor<element_t, 1> workgroup_reduce{local_range, cgh}; // stores the vertices to process at work-group granularity
-        sycl::local_accessor<uint32_t, 1> workgroup_reduce_tail{1, cgh}; // stores the tail of the work-group reduction
-        sycl::local_accessor<uint32_t, 1> workgroup_ids{local_range, cgh}; // stores the thread id that found the vertex to process at work-group level
-        sycl::local_accessor<element_t, 1> individual_reduce{local_range, cgh}; // stores the vertices to process at individual thread granularity
-        sycl::local_accessor<uint32_t, 1> individual_reduce_tail{1, cgh}; // stores the tail of the individual thread reduction
+        sycl::local_accessor<uint32_t, 1> n_edges_wg{
+            local_range,
+            cgh
+        }; // number of edges of vertices to process at work-group granularity
+        sycl::local_accessor<uint32_t, 1> n_edges_sg{
+            local_range,
+            cgh
+        }; // number of edges of vertices to process at sub-group granularity
+        sycl::local_accessor<bool, 1> visited{
+            local_range,
+            cgh
+        }; // tracks the vertices already visited at work-group and sub-group granularity
+        sycl::local_accessor<element_t, 1> subgroup_reduce{
+            local_range,
+            cgh
+        }; // stores the vertices to process at sub-group granularity
+        sycl::local_accessor<uint32_t, 1> subgroup_reduce_tail{
+            max_num_subgroups,
+            cgh
+        }; // stores the tail of the subgroup reduction
+        sycl::local_accessor<uint32_t, 1> subgroup_ids{
+            local_range,
+            cgh
+        }; // stores the thread id that found the vertex to process at sub-group level
+        sycl::local_accessor<element_t, 1> workgroup_reduce{
+            local_range,
+            cgh
+        }; // stores the vertices to process at work-group granularity
+        sycl::local_accessor<uint32_t, 1> workgroup_reduce_tail{
+            1,
+            cgh
+        }; // stores the tail of the work-group reduction
+        sycl::local_accessor<uint32_t, 1> workgroup_ids{
+            local_range,
+            cgh
+        }; // stores the thread id that found the vertex to process at work-group level
+        sycl::local_accessor<element_t, 1> individual_reduce{
+            local_range,
+            cgh
+        }; // stores the vertices to process at individual thread granularity
+        sycl::local_accessor<uint32_t, 1> individual_reduce_tail{
+            1,
+            cgh
+        }; // stores the tail of the individual thread reduction
 
         cgh.parallel_for(sycl::nd_range<1>{ global_range, local_range },
                          bitmap_kernel_t{ context,

cpp/oneapi/dal/backend/primitives/frontier/bitset.hpp

@@ -27,12 +27,15 @@ template <typename ElementType = std::uint32_t>
 class bitset {
 public:
     using element_t = ElementType;
-    static constexpr std::uint64_t element_bitsize = sizeof(element_t) * 8; // Number of bits in an element
+    static constexpr std::uint64_t element_bitsize =
+        sizeof(element_t) * 8; // Number of bits in an element
 
     /// Constructs a bitset with the given data pointer and number of items.
     /// \param data pointer to the underlying data.
     /// \param num_items number of items in the bitset.
-    bitset(element_t* data, const size_t num_items) : _data(data), _num_items((num_items + element_bitsize - 1) / element_bitsize) {}
+    bitset(element_t* data, const size_t num_items)
+            : _data(data),
+              _num_items((num_items + element_bitsize - 1) / element_bitsize) {}
 
     /// Sets the bit at the specified index to 1.
     inline void set(std::uint32_t index) const {

cpp/oneapi/dal/backend/primitives/frontier/frontier.hpp

@@ -33,14 +33,19 @@ class frontier_view {
     static constexpr std::uint64_t divide_factor = bitset<bitmap_t>::element_bitsize;
 
     frontier_view() = default;
-    frontier_view(bitmap_t* data_layer, // First layer (tracks vertices in the frontier)
-                  bitmap_t* mlb_layer, // Second layer (to track non-zero elements in the first layer)
-                  std::uint32_t* offsets, // Array to store the indices of the non-zero elements
-                  std::uint32_t* offsets_size, // Pointer to store the size of the offsets array
-                  std::uint64_t num_items) // Maximum number of items that can be stored in the frontier
+    frontier_view(
+        bitmap_t* data_layer, // First layer (tracks vertices in the frontier)
+        bitmap_t* mlb_layer, // Second layer (to track non-zero elements in the first layer)
+        std::uint32_t* offsets, // Array to store the indices of the non-zero elements
+        std::uint32_t* offsets_size, // Pointer to store the size of the offsets array
+        std::uint64_t num_items) // Maximum number of items that can be stored in the frontier
             : _num_items(num_items),
-              _data_layer(bitset<bitmap_t>{ data_layer, num_items }), // first layer size is num_items
-              _mlb_layer(bitset<bitmap_t>{ mlb_layer, (num_items + divide_factor - 1) / divide_factor }), // second layer size is ceil(num_items / divide_factor) because each bit in the second layer represents an element in the first layer
+              _data_layer(
+                  bitset<bitmap_t>{ data_layer, num_items }), // first layer size is num_items
+              _mlb_layer(bitset<bitmap_t>{
+                  mlb_layer,
+                  (num_items + divide_factor - 1) /
+                      divide_factor }), // second layer size is ceil(num_items / divide_factor) because each bit in the second layer represents an element in the first layer
               _offsets(offsets),
               _offsets_size(offsets_size) {}
 
@@ -153,7 +158,8 @@ class frontier {
     ndarray<std::uint32_t, 1> _offsets;
     ndarray<buffer_t, 1> _buffer;
     const std::uint64_t _TMP_VAR = 0;
-    const std::uint64_t _CAF_FLAG = 1; // Compute Active Frontier Flag (1 if already computed, 0 otherwise)
+    const std::uint64_t _CAF_FLAG =
+        1; // Compute Active Frontier Flag (1 if already computed, 0 otherwise)
 };
 
 /// Swaps the contents of two frontiers.

cpp/oneapi/dal/backend/primitives/frontier/frontier_dpc.cpp

@@ -108,8 +108,8 @@ inline sycl::event frontier<ElementType>::compute_active_frontier() {
     const std::uint64_t local_range = 256; // propose_wg_size(this->_queue);
     const std::uint64_t mlb_count = _mlb_layer.get_count();
     const std::uint64_t global_range = (mlb_count % local_range == 0)
-                                    ? mlb_count
-                                    : (mlb_count + local_range - (mlb_count % local_range));
+                                           ? mlb_count
+                                           : (mlb_count + local_range - (mlb_count % local_range));
 
     // check if local memory is enough
     bool use_local_mem =

cpp/oneapi/dal/backend/primitives/frontier/graph.hpp

@@ -69,7 +69,10 @@ class csr_graph_view {
     };
 
 public:
-    csr_graph_view(std::uint64_t num_nodes, vertex_t* row_ptr, edge_t* col_indices, weight_t* weights)
+    csr_graph_view(std::uint64_t num_nodes,
+                   vertex_t* row_ptr,
+                   edge_t* col_indices,
+                   weight_t* weights)
             : _num_nodes(num_nodes),
               _row_ptr(row_ptr),
               _col_indices(col_indices),