Implemented outputting to the nanoVDB file format.

.github/workflows/Ubuntu.yml

@@ -14,6 +14,8 @@ jobs:
         with:
           cuda: '11.7.0'
           linux-local-args: '["--toolkit"]'
+      - run: sudo apt-get update 
+      - run: sudo apt-get install -y xorg-dev libglu1-mesa-dev freeglut3-dev mesa-common-dev
       - run: nvcc -V      
       - name: Checkout
         uses: actions/checkout@v2            

.gitignore

@@ -53,3 +53,6 @@ temp
 docs/doxygen/html/
 
 docs/doxygen/latex/
+
+!apps/lbmMultiRes/practice_v28.obj
+!apps/lbmMultiRes/sphere3.obj

CMakeLists.txt

@@ -10,6 +10,18 @@ if ("${CMAKE_BUILD_TYPE}" STREQUAL "")
     set(CMAKE_BUILD_TYPE Release)
 endif ()
 
+if (WIN32)
+	set(LIBIGL_USE_STATIC_LIBRARY "ON" CACHE BOOL "Use Libigl as a static library")
+	set(NEON_USE_POLYSCOPE "ON" CACHE BOOL "Enable Ployscope for visualization")
+endif()
+
+if(${NEON_USE_POLYSCOPE})
+	message(STATUS "Polyscope is enabled")
+else()
+	message(STATUS "Polyscope is disabled")
+endif()
+
+
 # Manage between building Neon as shared or static library
 include("${PROJECT_SOURCE_DIR}/cmake/ManageLibraryType.cmake")
 
@@ -70,6 +82,9 @@ if (NOT OpenMP_CXX_FOUND)
     message(FATAL_ERROR "Neon could not find OpenMP")
 endif ()
 target_link_libraries(NeonDeveloperLib INTERFACE OpenMP::OpenMP_CXX)
+if(${NEON_USE_POLYSCOPE})
+	target_compile_definitions(NeonDeveloperLib INTERFACE NEON_USE_POLYSCOPE)
+endif()
 
 #target_link_libraries(libNeonXXX INTERFACE $<BUILD_INTERFACE:NeonDeveloperLib>)
 
@@ -79,7 +94,7 @@ add_subdirectory("libNeonSet")
 add_subdirectory("libNeonDomain")
 add_subdirectory("libNeonSkeleton")
 #add_subdirectory("libNeonSolver")
-#add_subdirectory("tutorials")
+add_subdirectory("tutorials")
 add_subdirectory("apps")
 add_subdirectory("benchmarks")
 

README.md

@@ -1,5 +1,7 @@
 ![Neon logo](docs/logo/neonDarkLogo.jpg "Neon")
 
+# For information about the GPU LBM Grid Refinement work (IPDPS 2024), go to this [README](https://github.com/Autodesk/Neon/blob/v0.5.1/apps/lbmMultiRes/README.md)
+
 Neon is a research framework for programming multi-device systems maintained by [Autodesk Research](https://www.autodesk.com/research/overview). Neon's goal is to automatically transform user sequential code into, for example, a scalable multi-GPU execution.
 
 To reach its goal, Neon takes a domain-specific approach based on the parallel skeleton philosophy (a.k.a parallel patterns). Neon provides a set of domain-specific and programmable patterns that users compose through a sequential programming model to author their applications. Then, thanks to the knowledge of the domain, the patterns and their composition, Neon automatically optimizes the sequential code into an execution optimized for multi-device systems.

apps/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.19 FATAL_ERROR)
 
-#add_subdirectory("fractal")
-#add_subdirectory("lbm")
-#add_subdirectory("gameOfLife")
+add_subdirectory("fractal")
+add_subdirectory("lbm")
+add_subdirectory("gameOfLife")
 #add_subdirectory("poisson")
-add_subdirectory("lbmMultiRes")
+#add_subdirectory("lbmMultiRes")

apps/fractal/fractal.cu

@@ -5,8 +5,8 @@
 #include "Neon/domain/dGrid.h"
 #include "Neon/skeleton/Skeleton.h"
 
-template <typename FieldT>
-inline void draw_pixels(const int t, FieldT& field)
+template <typename Field>
+inline void draw_pixels(const int t, Field& field)
 {
     printf("\n Exporting Frame =%d", t);
     int                precision = 4;
@@ -28,19 +28,19 @@ NEON_CUDA_HOST_DEVICE inline Neon::float_2d complex_pow(Neon::float_2d& z, Neon:
     return Neon::float_2d(radius * cos(angle), radius * sin(angle));
 }
 
-template <typename FieldT>
-inline Neon::set::Container FractalsContainer(FieldT&  pixels,
+template <typename Field>
+inline Neon::set::Container FractalsContainer(Field&  pixels,
                                               int32_t& time,
                                               int32_t  n)
 {
-    return pixels.getGrid().getContainer(
+    return pixels.getGrid().newContainer(
         "FractalContainer", [&, n](Neon::set::Loader& L) {
             auto& px = L.load(pixels);
             auto& t = time;
 
             return [=] NEON_CUDA_HOST_DEVICE(
-                       const typename FieldT::Cell& idx) mutable {
-                auto id = px.mapToGlobal(idx);
+                       const typename Field::Idx& idx) mutable {
+                auto id = px.getGlobalIndex(idx);
 
                 Neon::float_2d c(-0.8, cos(t * 0.03) * 0.2);
                 Neon::float_2d z((float(id.x) / float(n)) - 1.0f,
@@ -59,7 +59,7 @@ inline Neon::set::Container FractalsContainer(FieldT&  pixels,
 int main(int argc, char** argv)
 {
     Neon::init();
-    if (Neon::sys::globalSpace::gpuSysObjStorage.numDevs() > 0) {
+    if ( Neon::Backend::countAvailableGpus() > 0) {
         int32_t          n = 320;
         Neon::index_3d   dim(2 * n, n, 1);
         std::vector<int> gpu_ids{0};
@@ -90,7 +90,7 @@ int main(int argc, char** argv)
             skeleton.run();
 
             pixels.updateHostData(0);
-            //draw_pixels(time, pixels);
+            draw_pixels(time, pixels);
         }
     }
 }

apps/gameOfLife/gameOfLife.cu

@@ -11,10 +11,10 @@
 #include "Neon/domain/dGrid.h"
 #include "Neon/skeleton/Skeleton.h"
 
-template <typename FieldT>
-inline void exportVTI(FieldT& voxel_1, FieldT& voxel_2, int frame_id)
+template <typename Field>
+inline void exportVTI(Field& voxel_1, Field& voxel_2, int frame_id)
 {
-    auto io = [&](int f, FieldT& voxel) {
+    auto io = [&](int f, Field& voxel) {
         printf("\n Exporting Frame =%d", f);
         int precision = 4;
         voxel.updateHostData(0);
@@ -39,66 +39,66 @@ Neon::domain::Stencil createStencil()
     return Neon::domain::Stencil(stencil);
 }
 
-template <typename FieldT>
-inline Neon::set::Container GoLContainer(const FieldT&         in_cells,
-                                         FieldT&               out_cells,
-                                         typename FieldT::Type length)
+template <typename Field>
+inline Neon::set::Container GoLContainer(const Field&         in_cells,
+                                         Field&               out_cells,
+                                         typename Field::Type length)
 {
-    using T = typename FieldT::Type;
-    return in_cells.getGrid().getContainer(
+    using T = typename Field::Type;
+    return in_cells.getGrid().newContainer(
         "GoLContainer", [&, length](Neon::set::Loader& L) {
-            const auto& ins = L.load(in_cells, Neon::Compute::STENCIL);
+            const auto& ins = L.load(in_cells, Neon::Pattern::STENCIL);
             auto&       out = L.load(out_cells);
 
             return [=] NEON_CUDA_HOST_DEVICE(
-                       const typename FieldT::Cell& idx) mutable {
-                typename FieldT::ngh_idx ngh(0, 0, 0);
-                const T                  default_value = 0;
-                int                      alive = 0;
-                T                        value = 0;
-                T                        status = ins.nghVal(idx, ngh, 0, default_value).value;
+                       const typename Field::Idx& idx) mutable {
+                typename Field::NghIdx ngh(0, 0, 0);
+                const T                 default_value = 0;
+                int                     alive = 0;
+                T                       value = 0;
+                T                       status = ins.getNghData(idx, ngh, 0, default_value).getData();
 
                 //+x
                 ngh.x = 1;
                 ngh.y = 0;
                 ngh.z = 0;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
                 ngh.y = 1;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
 
                 //-x
                 ngh.x = -1;
                 ngh.y = 0;
                 ngh.z = 0;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
                 ngh.y = -1;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
 
                 //+y
                 ngh.x = 0;
                 ngh.y = 1;
                 ngh.z = 0;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
                 ngh.x = -1;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
 
                 //-y
                 ngh.x = 0;
                 ngh.y = -1;
                 ngh.z = 0;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
                 ngh.x = 1;
-                value = ins.nghVal(idx, ngh, 0, default_value).value;
+                value = ins.getNghData(idx, ngh, 0, default_value).getData();
                 alive += (value > 0.0 ? 1 : 0);
 
-                auto id_global = ins.mapToGlobal(idx);
+                auto id_global = ins.getGlobalIndex(idx);
                 out(idx, 0) = ((T)id_global.x / length) * (T)((alive == 3 || (alive == 2 && status) ? 1 : 0));
             };
         });