Update clang-format include order rules (#38)

We should be including the sycl.hpp header from the sycl/ folder.
Changing from CL/sycl to sycl/sycl started forcing some header file
reordering, which caused pre-commit failures in the CI. So I have
changed the clang-format rules to better express what we want, which
has then caused other formatting changes for files that were not already
compliant to my dread will.

* all "headers.hpp"
* <third_party/includes.h>
* <sycl/sycl.hpp>
* <cppstdlibheaders>

Other than that, changing the matmul header caused the `cl::` namespace
to disappear, so was removed. Other formatting in the tuple_utils header
started becoming a bit nasty so knowing that SYCL requires C++ 17, I
changed to `decltype(auto)` for some of the function return types.
This is a bit more terse and functions exactly the same as the previous
version.

.clang-format

@@ -1,18 +1,13 @@
 BasedOnStyle: Google
+IncludeBlocks: Regroup
 IncludeCategories:
-  - Regex:           '^<sycl/.*>$'
-    Priority:        3
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '^<.*\.h>'
+  - Regex:           '^".*"'
     Priority:        1
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '^<.*'
+  - Regex:           '^<sycl/'
     Priority:        2
-    SortPriority:    0
-    CaseSensitive:   false
-  - Regex:           '.*'
+    SortPriority:    3
+  - Regex:           '<[[:alnum:]_/]+\.(h|hpp)>'
+    Priority:        3
+    SortPriority:    2
+  - Regex:           '<^[.]+>'
     Priority:        4
-    SortPriority:    0
-    CaseSensitive:   false

.gitignore

@@ -30,3 +30,6 @@
 *.exe
 *.out
 *.app
+
+# folders
+*build*/

src/fluid/fluid.h

@@ -20,15 +20,15 @@
 
 #pragma once
 
+#include <sycl/sycl.hpp>
+
 #include <algorithm>  // std::fill
 #include <cmath>      // std::round
 #include <cstdlib>    // std::size_t
 #include <exception>  // std::exception_ptr
 #include <iostream>   // std::cout, std::endl
 #include <vector>     // std::vector
 
-#include <sycl/sycl.hpp>
-
 // Kernel declarations.
 class fluid_boundary;
 class fluid_linear_solve;

src/fluid/main.cpp

@@ -18,6 +18,8 @@
  *
  **************************************************************************/
 
+#include "fluid.h"
+
 #include <Corrade/Containers/StringStlView.h>
 #include <Magnum/GL/DefaultFramebuffer.h>
 #include <Magnum/GL/Mesh.h>
@@ -33,8 +35,6 @@
 
 #include <sycl/sycl.hpp>
 
-#include "fluid.h"
-
 constexpr Magnum::PixelFormat PIXELFORMAT{Magnum::PixelFormat::RGBA8Unorm};
 
 // Title bar text

src/game_of_life/main.cpp

@@ -18,6 +18,8 @@
  *
  **************************************************************************/
 
+#include "sim.hpp"
+
 #include <Magnum/GL/DefaultFramebuffer.h>
 #include <Magnum/GL/Mesh.h>
 #include <Magnum/GL/Texture.h>
@@ -30,12 +32,10 @@
 #include <Magnum/Shaders/FlatGL.h>
 #include <Magnum/Trade/MeshData.h>
 
-#include <chrono>
-#include <thread>
-
 #include <sycl/sycl.hpp>
 
-#include "sim.hpp"
+#include <chrono>
+#include <thread>
 
 constexpr Magnum::PixelFormat PIXELFORMAT{Magnum::PixelFormat::RGBA8Unorm};
 

src/game_of_life/sim.hpp

@@ -20,11 +20,11 @@
 
 #pragma once
 
-#include <random>
+#include "../include/double_buf.hpp"
 
 #include <sycl/sycl.hpp>
 
-#include "../include/double_buf.hpp"
+#include <random>
 
 enum class CellState : unsigned int {
   LIVE = 1,

src/mandelbrot/main.cpp

@@ -18,6 +18,8 @@
  *
  **************************************************************************/
 
+#include "mandel.hpp"
+
 #include <Magnum/GL/DefaultFramebuffer.h>
 #include <Magnum/GL/Mesh.h>
 #include <Magnum/GL/Texture.h>
@@ -32,8 +34,6 @@
 
 #include <sycl/sycl.hpp>
 
-#include "mandel.hpp"
-
 constexpr size_t WIDTH = 800;
 constexpr size_t HEIGHT = 600;
 constexpr Magnum::PixelFormat PIXELFORMAT{Magnum::PixelFormat::RGBA8Unorm};

src/matrix_multiply_omp_compare/matrix-multiply.cpp

@@ -24,13 +24,14 @@
  *  and differences between them.
  *  See block_host for the OpenMP implementation. */
 
-#include <CL/sycl.hpp>
+#include <sycl/sycl.hpp>
+
 #include <chrono>
 #include <cmath>
 #include <ctime>
 #include <iostream>
 
-using namespace cl::sycl;
+using namespace sycl;
 
 class mxm_kernel;
 
@@ -111,7 +112,7 @@ inline bool isPowerOfTwo(int x) { return (x & (x - 1)) == 0; }
  * Note that this example only works for powers of two.
  * */
 template <typename T>
-bool local_mxm(cl::sycl::queue& q, T* MA, T* MB, T* MC, int matSize) {
+bool local_mxm(sycl::queue& q, T* MA, T* MB, T* MC, int matSize) {
   // Make sure it is power of two before running
   if (!isPowerOfTwo(matSize)) {
     std::cout << " This example only works with power of two sizes "
@@ -121,7 +122,7 @@ bool local_mxm(cl::sycl::queue& q, T* MA, T* MB, T* MC, int matSize) {
 
   auto device = q.get_device();
   auto maxBlockSize =
-      device.get_info<cl::sycl::info::device::max_work_group_size>();
+      device.get_info<sycl::info::device::max_work_group_size>();
   auto blockSize = prevPowerOfTwo(std::sqrt(maxBlockSize));
   std::cout << " The Device Max Work Group Size is : " << maxBlockSize
             << std::endl;
@@ -324,14 +325,13 @@ int main(int argc, char* argv[]) {
          * to capture potential asynchronous errors. This function will be
          * called every time there is an asynchronous error on the queue (i.e.
          * some error occurs while the queue is executing kernels) and one of
-         * cl::sycl::queue::throw() or cl::sycl::queue::wait_and_throw() is
-         * called. */
+         * sycl::queue::throw() or sycl::queue::wait_and_throw() is called. */
         queue q([&](exception_list eL) {
           try {
             for (auto& e : eL) {
               std::rethrow_exception(e);
             }
-          } catch (cl::sycl::exception e) {
+          } catch (sycl::exception e) {
             std::cout << " An exception has been thrown: " << e.what()
                       << std::endl;
           }

src/nbody/InteropGLBuffer.hpp

@@ -10,6 +10,8 @@
 #define CUDA_GL_INTEROP_API_AVAILABLE 0
 #endif
 
+#include <iostream>
+
 /// @brief Magnum GL Buffer wrapper implementing backend-specific interop to
 /// work directly on OpenGL device buffers instead of using host memory.
 ///

src/nbody/main.cpp

@@ -18,6 +18,9 @@
  *
  **************************************************************************/
 
+#include "InteropGLBuffer.hpp"
+#include "sim.hpp"
+
 #include <Corrade/PluginManager/Manager.h>
 #include <Corrade/Utility/Resource.h>
 #include <Magnum/GL/AbstractShaderProgram.h>
@@ -28,6 +31,7 @@
 #include <Magnum/GL/Texture.h>
 #include <Magnum/GL/TextureFormat.h>
 #include <Magnum/GL/Version.h>
+#include <Magnum/ImGuiIntegration/Context.hpp>
 #include <Magnum/ImageView.h>
 #include <Magnum/Magnum.h>
 #include <Magnum/Math/Angle.h>
@@ -40,14 +44,10 @@
 #include <Magnum/Trade/ImageData.h>
 #include <Magnum/Trade/MeshData.h>
 
-#include <Magnum/ImGuiIntegration/Context.hpp>
-#include <chrono>
-#include <fstream>
-
 #include <sycl/sycl.hpp>
 
-#include "InteropGLBuffer.hpp"
-#include "sim.hpp"
+#include <chrono>
+#include <fstream>
 
 using num_t = float;
 constexpr num_t PI{3.141592653589793238462643383279502884197169399};

src/nbody/sim.hpp

@@ -20,17 +20,17 @@
 
 #pragma once
 
-#include <iostream>
-#include <memory>
-#include <random>
-
-#include <sycl/sycl.hpp>
-
 #include "../include/double_buf.hpp"
 #include "integrator.hpp"
 #include "sycl_bufs.hpp"
 #include "tuple_utils.hpp"
 
+#include <sycl/sycl.hpp>
+
+#include <iostream>
+#include <memory>
+#include <random>
+
 // Convenience types
 template <typename num_t>
 using vec3 = sycl::vec<num_t, 3>;

src/nbody/sycl_bufs.hpp

@@ -20,11 +20,11 @@
 
 #pragma once
 
-#include <type_traits>
+#include "tuple_utils.hpp"
 
 #include <sycl/sycl.hpp>
 
-#include "tuple_utils.hpp"
+#include <type_traits>
 
 // Template function object which transforms buffers to device read accessors
 struct BufToReadAccFunc {

src/nbody/tuple_utils.hpp

@@ -131,8 +131,7 @@ auto squash_tuple(Tuple&& tpl)
 namespace {
 template <typename TupleA, typename TupleB, size_t... Ids>
 auto add_tuples_help(TupleA&& a, TupleB&& b, index_sequence<Ids...>)
-    -> decltype(std::make_tuple(std::get<Ids>(std::forward<TupleA>(a)) +
-                                std::get<Ids>(std::forward<TupleB>(b))...)) {
+    -> decltype(auto) {
   return std::make_tuple(std::get<Ids>(std::forward<TupleA>(a)) +
                          std::get<Ids>(std::forward<TupleB>(b))...);
 }
@@ -143,9 +142,7 @@ template <
     size_t SizeA = std::tuple_size<typename std::decay<TupleA>::type>::value,
     size_t SizeB = std::tuple_size<typename std::decay<TupleB>::type>::value,
     typename Ids = make_index_sequence<SizeA>>
-auto add_tuples(TupleA&& a, TupleB&& b)
-    -> decltype(add_tuples_help(std::forward<TupleA>(a),
-                                std::forward<TupleB>(b), Ids{})) {
+auto add_tuples(TupleA&& a, TupleB&& b) -> decltype(auto) {
   static_assert(SizeA == SizeB, "Cannot add tuples of differing sizes.");
   return add_tuples_help(std::forward<TupleA>(a), std::forward<TupleB>(b),
                          Ids{});

src/scan_parallel_inclusive/scan.cpp

@@ -18,7 +18,8 @@
  *
  **************************************************************************/
 
-#include <CL/sycl.hpp>
+#include <sycl/sycl.hpp>
+
 #include <algorithm>
 #include <iostream>
 #include <numeric>