HPX support

CMakeLists.txt

@@ -17,6 +17,10 @@ SET(EMBREE_PROJECT_COMPILATION ON)
 
 include(CMakeDependentOption)
 
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
 # We use our own strip tool on macOS to sign during install. This is required as CMake modifies RPATH of the binary during install.
 IF (APPLE AND EMBREE_SIGN_FILE)
   SET(EMBREE_STRIP ${CMAKE_STRIP})
@@ -235,9 +239,11 @@ OPTION(EMBREE_MIN_WIDTH "Enables min-width feature to enlarge curve and point th
 IF (APPLE AND CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND (CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64" OR CMAKE_OSX_ARCHITECTURES MATCHES "arm64"))
   MESSAGE(STATUS "Building for Apple silicon")
   SET(EMBREE_ARM ON)
+  SET(EMBREE_ISA_AVX512SKX OFF)
 ELSEIF(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "ARM64")
   MESSAGE(STATUS "Building for AArch64")
   SET(EMBREE_ARM ON)
+  SET(EMBREE_ISA_AVX512SKX OFF)
 ENDIF()
 
 SET(EMBREE_TASKING_SYSTEM "TBB" CACHE STRING "Selects tasking system")
@@ -253,14 +259,33 @@ IF (EMBREE_TASKING_SYSTEM STREQUAL "TBB")
   SET(TASKING_TBB      ON )
   SET(TASKING_INTERNAL OFF)
   SET(TASKING_PPL      OFF )
+  SET(TASKING_HPX      OFF )
   ADD_DEFINITIONS(-DTASKING_TBB)
   LIST(APPEND ISPC_DEFINITIONS -DTASKING_TBB)
 ELSEIF (EMBREE_TASKING_SYSTEM STREQUAL "PPL")
   SET(TASKING_PPL      ON )
   SET(TASKING_TBB      OFF )
+  SET(TASKING_HPX      OFF )
   SET(TASKING_INTERNAL OFF)
   ADD_DEFINITIONS(-DTASKING_PPL)
   LIST(APPEND ISPC_DEFINITIONS -DTASKING_PPL)
+ELSEIF (EMBREE_TASKING_SYSTEM STREQUAL "HPX")
+  IF(NOT HPX_DIR AND HPX_ROOT)
+    SET(HPX_DIR ${HPX_ROOT}/lib/cmake/HPX)
+  ENDIF()
+
+  IF(NOT HPX_DIR AND EXISTS "$ENV{HPX_DIR}")
+    SET(HPX_DIR $ENV{HPX_DIR})
+  ENDIF()
+
+  UNSET(CMAKE_CXX_STANDARD)
+  SET(CMAKE_CXX_STANDARD 20)
+  SET(TASKING_HPX      ON )
+  SET(TASKING_PPL      OFF )
+  SET(TASKING_TBB      OFF )
+  SET(TASKING_INTERNAL OFF)
+  ADD_DEFINITIONS(-DTASKING_HPX)
+  LIST(APPEND ISPC_DEFINITIONS -DTASKING_HPX)
 ELSE()
   SET(TASKING_INTERNAL ON )
   SET(TASKING_TBB      OFF)
@@ -379,8 +404,10 @@ ELSE()
 ENDIF()
 
 IF (EMBREE_ARM)
+  message(STATUS "NEON, NEON2X")
   SET_PROPERTY(CACHE EMBREE_MAX_ISA PROPERTY STRINGS NONE NEON NEON2X)
 ELSE()  
+  message(STATUS "SSE2 SSE4.2 AVX AVX2 AVX512")
   SET_PROPERTY(CACHE EMBREE_MAX_ISA PROPERTY STRINGS NONE SSE2 SSE4.2 AVX AVX2 AVX512 DEFAULT)
 ENDIF()
 
@@ -390,9 +417,11 @@ IF (EMBREE_MAX_ISA STREQUAL "NONE")
     IF (APPLE)
       OPTION(EMBREE_ISA_NEON   "Enables NEON ISA." OFF)
       OPTION(EMBREE_ISA_NEON2X "Enables NEON ISA double pumped." ON)
+      TRY_COMPILE(COMPILER_SUPPORTS_ARM    "${CMAKE_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/common/cmake/check_isa.cpp" COMPILE_DEFINITIONS ${FLAGS_ARM})
     ELSE()
       OPTION(EMBREE_ISA_NEON   "Enables NEON ISA." ON)
       OPTION(EMBREE_ISA_NEON2X "Enables NEON ISA double pumped." OFF)
+      TRY_COMPILE(COMPILER_SUPPORTS_ARM    "${CMAKE_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/common/cmake/check_isa.cpp" COMPILE_DEFINITIONS ${FLAGS_ARM})
     ENDIF()
   ELSE()
     TRY_COMPILE(COMPILER_SUPPORTS_AVX    "${CMAKE_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/common/cmake/check_isa.cpp" COMPILE_DEFINITIONS ${FLAGS_AVX})

README.md

@@ -305,7 +305,7 @@ macOS M1
 
   - Apple Clang 12.0.5 (macOS 11.7.1)
 
-IMPORTANT: Unfortunatlly, latest version of the Intel® oneAPI DPC++/C++
+IMPORTANT: Unfortunately, latest version of the Intel® oneAPI DPC++/C++
 Compiler (2023.2.1), has a bug that doesn't allow Embree to run correctly with
 ISAs >= AVX2. Please wait for 2024.0.0, which will be released soon after
 Embree 4.3.0.
@@ -325,6 +325,11 @@ installation, put the path to `ispc` permanently into your `PATH` environment
 variable or you set the `EMBREE_ISPC_EXECUTABLE` variable to point at the ISPC
 executable during CMake configuration.
 
+Embree supports using the HPX runtime system as the tasking system. HPX can be
+enabled by setting `EMBREE_TASKING_SYSTEM=HPX`. If HPX is enabled the CMake
+variables `HPX_DIR` or `HPX_ROOT` are required to be set. The variables are
+file system paths where `HPXConfig.cmake` or `HPXConfigVersion.cmake` resides.
+
 You additionally have to install CMake 3.1.0 or higher and the developer
 version of [GLFW](https://www.glfw.org/) version 3.
 
@@ -818,8 +823,8 @@ parameters that can be configured in CMake:
 
 + `EMBREE_TASKING_SYSTEM`: Chooses between Intel® Threading TBB
   Building Blocks (TBB), Parallel Patterns Library (PPL) (Windows
-  only), or an internal tasking system (INTERNAL). By default, TBB is
-  used.
+  only), HPX (HPX), or an internal tasking system (INTERNAL). By default,
+  TBB is used.
 
 + `EMBREE_TBB_ROOT`: If Intel® Threading Building Blocks (TBB)
   is used as a tasking system, search the library in this directory

common/CMakeLists.txt

@@ -5,4 +5,4 @@ ADD_SUBDIRECTORY(sys)
 ADD_SUBDIRECTORY(math)
 ADD_SUBDIRECTORY(simd)
 ADD_SUBDIRECTORY(lexers)
-ADD_SUBDIRECTORY(tasking)
+ADD_SUBDIRECTORY(tasking)

common/algorithms/parallel_for.h

@@ -8,6 +8,11 @@
 #include "../math/emath.h"
 #include "../math/range.h"
 
+#if defined(TASKING_HPX)
+#include <hpx/algorithm.hpp>
+#include <hpx/modules/iterator_support.hpp>
+#endif
+
 namespace embree
 {
   /* parallel_for without range */
@@ -46,6 +51,20 @@ namespace embree
     concurrency::parallel_for(Index(0),N,Index(1),[&](Index i) { 
         func(i);
       });
+#elif defined(TASKING_HPX)
+    std::vector<hpx::future<void>> futures;
+    futures.reserve(N-1);
+
+    hpx::threads::run_as_hpx_thread([N, &func, &futures]() 
+    {
+        for(auto i = 1; i < N; ++i) {
+            futures.push_back( hpx::async([i, &func]() { func(i); }) );
+        }
+
+        func(0);
+        hpx::wait_all(futures);
+    });
+
 #else
 #  error "no tasking system enabled"
 #endif
@@ -84,7 +103,20 @@ namespace embree
     concurrency::parallel_for(first, last, Index(1) /*minStepSize*/, [&](Index i) { 
         func(range<Index>(i,i+1)); 
       });
+#elif defined(TASKING_HPX)
+    auto irange = hpx::util::counting_shape(last-first);
+
+    hpx::future<void> fut =
+        hpx::threads::run_as_hpx_thread([minStepSize, &irange, &func]() -> hpx::future<void> {
+            hpx::experimental::for_loop_strided(hpx::execution::par, hpx::util::begin(irange), hpx::util::end(irange), minStepSize,
+            [&func](auto i) {
+                func(range<Index>(*i, (*i)+1));
+            });
+
+            return hpx::make_ready_future<void>();
+    });
 
+    fut.wait();
 #else
 #  error "no tasking system enabled"
 #endif

common/algorithms/parallel_reduce.h

@@ -5,6 +5,11 @@
 
 #include "parallel_for.h"
 
+#if defined(TASKING_HPX)
+#include <numeric>
+#include <hpx/parallel/algorithms/transform_reduce.hpp>
+#endif
+
 namespace embree
 {
   template<typename Index, typename Value, typename Func, typename Reduction>
@@ -69,7 +74,7 @@ namespace embree
       throw std::runtime_error("task cancelled");
     return v;
   #endif
-#else // TASKING_PPL
+#elif defined(TASKING_PPL)
     struct AlignedValue
     {
       char storage[__alignof(Value)+sizeof(Value)];
@@ -107,6 +112,57 @@ namespace embree
     };
     const Value v = concurrency::parallel_reduce(Iterator_Index(first), Iterator_Index(last), AlignedValue(identity), range_reduction, reduction);
     return v;
+#elif defined(TASKING_HPX)
+/*    
+      binner = parallel_reduce(begin,end,blockSize,binner,
+                              [&](const range<size_t>& r) -> BinInfoT { BinInfoT binner(empty); binner.bin(prims + r.begin(), r.size(), mapping); return binner; },
+                              [&](const BinInfoT& b0, const BinInfoT& b1) -> BinInfoT { BinInfoT r = b0; r.merge(b1, mapping.size()); return r; });
+*/
+    struct AlignedValue
+    {
+      char storage[__alignof(Value)+sizeof(Value)];
+      static uintptr_t alignUp(uintptr_t p, size_t a) { return p + (~(p - 1) % a); };
+      Value* getValuePtr() { return reinterpret_cast<Value*>(alignUp(uintptr_t(storage), __alignof(Value))); }
+      const Value* getValuePtr() const { return reinterpret_cast<Value*>(alignUp(uintptr_t(storage), __alignof(Value))); }
+      AlignedValue(const Value& v) { new(getValuePtr()) Value(v); }
+      AlignedValue(const AlignedValue& v) { new(getValuePtr()) Value(*v.getValuePtr()); }
+      AlignedValue(const AlignedValue&& v) { new(getValuePtr()) Value(*v.getValuePtr()); };
+      AlignedValue& operator = (const AlignedValue& v) { *getValuePtr() = *v.getValuePtr(); return *this; };
+      AlignedValue& operator = (const AlignedValue&& v) { *getValuePtr() = *v.getValuePtr(); return *this; };
+      operator Value() const { return *getValuePtr(); }
+    };
+
+    std::function<AlignedValue(AlignedValue, AlignedValue)> red = [&](AlignedValue x, AlignedValue y) -> AlignedValue {
+        return AlignedValue(reduction(x, y));
+    };
+
+    std::function<AlignedValue(Index)> xfm = [&](Index i) -> AlignedValue {
+        return AlignedValue(func(range<Index>(i,i)));
+    };
+
+    const Index sz = last-first;
+    auto irange = hpx::util::counting_shape(sz);
+    auto beg = hpx::util::begin(irange);
+    auto end = hpx::util::end(irange);
+
+    Value v =
+        hpx::threads::run_as_hpx_thread([&red, &xfm, &beg, &end, &identity]() -> Value
+        {
+
+            Value v = hpx::transform_reduce(
+                hpx::execution::par,
+                beg, end,
+                AlignedValue(identity),
+                red,
+                xfm
+            );
+
+            return v;
+        });
+
+    return v;
+#else
+#  error "no tasking system enabled"
 #endif
   }
 

common/cmake/check_isa.cpp

@@ -26,6 +26,10 @@ char const *info_isa = "ISA" ":" "AVX";
 char const *info_isa = "ISA" ":" "SSE42";
 #else // defined(__SSE2__)
 char const *info_isa = "ISA" ":" "SSE2";
+#else defined(__arm__)
+char const *info_isa = "ISA" ":" "ARM";
+#else defined(__aarch64__)
+char const *info_isa = "ISA" ":" "ARM";
 #endif
 
 int main(int argc, char **argv)

common/cmake/clang.cmake

@@ -127,7 +127,9 @@ ELSE()
   SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3")             # enable full optimizations
 
   IF (APPLE)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.7")   # makes sure code runs on older MacOSX versions
+    IF(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
+      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.7")   # makes sure code runs on older MacOSX versions
+    ENDIF()
     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")             # link against libc++ which supports C++11 features
   ELSE(APPLE)
     IF (NOT EMBREE_ADDRESS_SANITIZER) # for address sanitizer this causes link errors
@@ -140,6 +142,10 @@ ELSE()
         SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -z noexecstack")           # we do not need an executable stack
       ENDIF()
     ENDIF()
+
+    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-aligned-allocation")
+    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-aligned-allocation")
+    SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fno-aligned-allocation")
   ENDIF(APPLE)
 
 

common/sys/CMakeLists.txt

@@ -1,8 +1,10 @@
 ## Copyright 2009-2021 Intel Corporation
 ## SPDX-License-Identifier: Apache-2.0
 
-SET(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-FIND_PACKAGE(Threads REQUIRED)
+IF(NOT TASKING_HPX)
+  SET(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+  FIND_PACKAGE(Threads REQUIRED)
+endif()
 
 ADD_LIBRARY(sys STATIC
   sysinfo.cpp
@@ -20,9 +22,28 @@ ADD_LIBRARY(sys STATIC
 SET_PROPERTY(TARGET sys PROPERTY FOLDER common)
 SET_PROPERTY(TARGET sys APPEND PROPERTY COMPILE_FLAGS " ${FLAGS_LOWEST}")
 
-TARGET_LINK_LIBRARIES(sys ${CMAKE_THREAD_LIBS_INIT} ${CMAKE_DL_LIBS})
-IF (EMBREE_SYCL_SUPPORT)
-  TARGET_LINK_LIBRARIES(sys ${SYCL_LIB_NAME})
+IF(TASKING_HPX)
+  IF(HPX_FOUND)
+    TARGET_INCLUDE_DIRECTORIES(sys PUBLIC "${HPX_INCLUDE_DIRS}")
+    TARGET_LINK_LIBRARIES(sys PUBLIC ${CMAKE_DL_LIBS} HPX::hpx)
+  ELSE()
+    find_package(HPX REQUIRED)
+    IF(HPX_FOUND)
+      TARGET_INCLUDE_DIRECTORIES(sys PUBLIC "${HPX_INCLUDE_DIRS}")
+      IF (EMBREE_SYCL_SUPPORT)
+        TARGET_LINK_LIBRARIES(sys PUBLIC {CMAKE_DL_LIBS} ${SYCL_LIB_NAME} HPX::hpx)
+      ELSE()
+        TARGET_LINK_LIBRARIES(sys PUBLIC ${CMAKE_DL_LIBS} HPX::hpx)
+      ENDIF()
+    ELSE()
+      message("-- Not found HPX")
+    ENDIF()
+  ENDIF()
+ELSE()
+  TARGET_LINK_LIBRARIES(sys ${CMAKE_THREAD_LIBS_INIT} ${CMAKE_DL_LIBS})
+  IF (EMBREE_SYCL_SUPPORT)
+    TARGET_LINK_LIBRARIES(sys ${SYCL_LIB_NAME})
+  ENDIF()
 ENDIF()
 
 IF (EMBREE_STATIC_LIB)

common/sys/barrier.cpp

@@ -101,7 +101,7 @@ namespace embree
     __forceinline void wait()
     {
       mutex.lock();
-      count++;
+      count+=1;
 
       if (count == barrierSize) {
         count = 0;
@@ -128,19 +128,33 @@ namespace embree
 namespace embree
 {
   BarrierSys::BarrierSys (size_t N) {
+#if defined(TASKING_HPX)
+    b = std::make_shared<hpx::barrier<>>(N);
+#else
     opaque = new BarrierSysImplementation(N);
+#endif
   }
 
   BarrierSys::~BarrierSys () {
+#if !defined(TASKING_HPX)
     delete (BarrierSysImplementation*) opaque;
+#endif
   }
 
   void BarrierSys::init(size_t count) {
+#if defined(TASKING_HPX)
+    b.reset(new hpx::barrier<>(count));
+#else
     ((BarrierSysImplementation*) opaque)->init(count);
+#endif
   }
 
   void BarrierSys::wait() {
+#if defined(TASKING_HPX)
+    b->arrive_and_wait();
+#else
     ((BarrierSysImplementation*) opaque)->wait();
+#endif
   }
 
   LinearBarrierActive::LinearBarrierActive (size_t N) 

common/sys/barrier.h

@@ -7,6 +7,11 @@
 #include "sysinfo.h"
 #include "atomic.h"
 
+#if defined(TASKING_HPX)
+#include <memory>
+#include <hpx/barrier.hpp>
+#endif
+
 namespace embree
 {
   /*! system barrier using operating system */
@@ -31,7 +36,12 @@ namespace embree
     void wait();
 
   private:
+
+#if defined(TASKING_HPX)
+    std::shared_ptr< hpx::barrier<> > b;
+#else
     void* opaque;
+#endif
   };
 
   /*! fast active barrier using atomic counter */