Flow control

CMakeLists.txt

@@ -7,11 +7,12 @@ project (graph_framework CXX)
 #-------------------------------------------------------------------------------
 option (USE_PCH "Enable the use of precompiled headers" ON)
 option (SAVE_KERNEL_SOURCE "Writes the kernel source code to a file." OFF)
-option (USE_INPUT_CACHE "Cache the values kernel input values." OFF)
-option (USE_CONSTANT_CACHE "Cache the value of constants in kernel registers." OFF)
+option (USE_INPUT_CACHE "Cache the values kernel input values." ON)
+option (USE_CONSTANT_CACHE "Cache the value of constants in kernel registers." ON)
 option (SHOW_USE_COUNT "Add a comment showing the use count in kernel sources." OFF)
-option (USE_INDEX_CACHE "Cache index values instead of computing them every time." OFF)
+option (USE_INDEX_CACHE "Cache index values instead of computing them every time." ON)
 option (USE_VERBOSE "Verbose jit option." OFF)
+option (PROFILE_KERNELS "Display kernel timing information" OFF)
 option (BUILD_C_BINDING "Build C interface." OFF)
 option (BUILD_Fortran_BINDING "Build Fortran interface." OFF)
 
@@ -207,6 +208,7 @@ FetchContent_GetProperties (
 )
 
 #  Do not build llvm until pull command is finished.
+add_dependencies (CASPluginTest_exports pull_llvm)
 add_dependencies (gpu-resource-headers pull_llvm)
 add_dependencies (llvm-offload-resource-headers pull_llvm)
 add_dependencies (LLVMDemangle pull_llvm)
@@ -374,8 +376,12 @@ macro (add_tool_target target lang)
                            graph_framework
     )
 
-    if (${USE_PCH} AND ${BUILD_C_BINDING})
-        target_precompile_headers (${target} REUSE_FROM graph_c)
+    if (${USE_PCH})
+        if (${BUILD_C_BINDING})
+            target_precompile_headers (${target} REUSE_FROM graph_c)
+        elseif (NOT ${target} MATCHES xrays)
+            target_precompile_headers (${target} REUSE_FROM xrays)
+        endif ()
     endif ()
 endmacro ()
 
@@ -404,4 +410,18 @@ macro (add_test_target target lang)
     endif ()
 endmacro ()
 
+macro (add_compile_test target lang)
+    cmake_path (GET CMAKE_CXX_COMPILER FILENAME compiler_command)
+    add_test (NAME ${target}_off
+              COMMAND ${compiler_command} -std=c++23 -DUSE_VERBOSE=false -DCHECK_TEST -c ${CMAKE_CURRENT_SOURCE_DIR}/${target}.${lang}
+    )
+    add_test (NAME ${target}_on
+              COMMAND ${compiler_command} -std=c++23 -DUSE_VERBOSE=false -c ${CMAKE_CURRENT_SOURCE_DIR}/${target}.${lang}
+    )
+    set_tests_properties (${target}_on
+                          PROPERTIES
+                          WILL_FAIL true
+    )
+endmacro ()
+
 add_subdirectory (graph_tests)

graph_docs/code_performance.dox

@@ -25,7 +25,7 @@
  *
  * The figure above shows the advantage even a single GPU has over CPU
  * execution. In single precision, the M2's GPU is almost @f$100\times@f$ faster
- * a single CPU core while the a single A100 has a nearly $800\times$ advantage.
+ * a single CPU core while the a single A100 has a nearly @f$800\times@f$ advantage.
  * An interesting thing to note is the M2 Max CPU show no advantage between
  * single and double precision execution.
  *
@@ -112,7 +112,7 @@ for (size_t i = 0, ie = threads.size(); i < ie; i++) {
             {v_next->get_x(), graph::variable_cast(vx)},
             {v_next->get_y(), graph::variable_cast(vy)},
             {v_next->get_z(), graph::variable_cast(vz)}
-        }, NULL, "Lorentz_kernel", local_size);
+        }, {}, NULL, "Lorentz_kernel", local_size);
         work.compile();
 
         time_steps.start_time(thread_number);

graph_docs/discription.dox

@@ -39,9 +39,9 @@
  * expression nodes. The factory method checks a node_cache to avoid building
  * duplicate sub-graphs. Identification of duplicate graphs is performed by
  * computing a hash of the sub-graph. This hash can be rapidly checked if the
- * same hash already exists in a <tt>std::map</tt> container. If the sub-graph
- * already exists, the existing graph is returned otherwise a new sub-graph is
- * registered in the node_cache.
+ * same hash already exists in a <tt>std::unordered_map</tt> container. If the
+ * sub-graph already exists, the existing graph is returned otherwise a new
+ * sub-graph is registered in the node_cache.
  *
  * Each time an expression is built, the reduce method is called to simplify the
  * graph. For instance, a graph consisting of constant added to a constant will

graph_docs/kernel_optimization.dox

@@ -57,7 +57,7 @@ void field_solve_example() {
                         + graph::exp(static_cast<T> (-1)*arg*arg/static_cast<T> (10));
     }
 
-    auto state = graph::random_state<T> (jit::context<T>::random_state_size, 0);
+    auto state = graph::random_state<T> (jit::context<T>::max_random_state_size(num_particles), 0);
     auto random = graph::random<T> (graph::random_state_cast(state));
     const T max = 1.0;
     const T min = -1.0;
@@ -68,7 +68,7 @@ void field_solve_example() {
     timing::measure_diagnostic compile("compile");
 
     workflow::manager<T> work(0);
-    work.add_preitem({
+    work.add_item<workflow::order::pre_item> ({
         graph::variable_cast(particle_positions)
     }, {}, {
         {random_real, variable_cast(particle_positions)}

graph_docs/use_cases.dox

@@ -125,7 +125,7 @@
  * branch is absorbed in the upper hybrid resonance, @f$\omega_{h}@f$, while the
  * O-Mode branch can pass through it.
  *
- * @subsubsection use_cases_rf_correctness Comparison to GENRAY
+ * @subsubsection use_cases_rf_correctness_genray Comparison to GENRAY
  * <a href="https://compxco.com/genray.html">Genray</a> is an RF-Ray tracing
  * code written in Fortran which operates in a cylindrical geometry. Toroidal
  * equilibria can be imported using the

graph_driver/xrays.cpp

@@ -740,7 +740,7 @@ void bin_power(const commandline::parser &cl,
                 {z, graph::variable_cast(z_last)},
                 {p_next, graph::variable_cast(power)},
                 {k_next, graph::variable_cast(k_sum)}
-            }, graph::shared_random_state<T, SAFE_MATH> (), "power", local_num_rays);
+            }, {}, NULL, "power", local_num_rays);
             work.compile();
 
             output::result_file file(stream.str());

graph_fortran_binding/graph_fortran_binding.f90

@@ -568,14 +568,16 @@ TYPE(C_PTR) FUNCTION graph_atan(c, left, right)                       &
 !>  @brief Construct a random state node.
 !>
 !>  @param[in] c    The graph C context.
+!>  @param[in] size Number of randoms needed.
 !>  @param[in] seed Initial random seed.
 !>  @returns A random state node.
 !-------------------------------------------------------------------------------
-         TYPE(C_PTR) FUNCTION graph_random_state(c, seed)                      &
+         TYPE(C_PTR) FUNCTION graph_random_state(c, size, seed)                &
          BIND(C, NAME='graph_random_state')
          USE, INTRINSIC :: ISO_C_BINDING
          IMPLICIT NONE
          TYPE(C_PTR), VALUE        :: c
+         INTEGER(C_LONG), value    :: size
          INTEGER(C_INT32_T), VALUE :: seed
          END FUNCTION
 
@@ -742,13 +744,16 @@ SUBROUTINE graph_set_device_number(c, num)                            &
 !>  @param[in] map_inputs    Array of map input nodes.
 !>  @param[in] map_outputs   Array of map output nodes.
 !>  @param[in] num_maps      Number of maps.
+!>  @param[in] atomics       Array of atomics nodes.
+!>  @param[in] num_atomics   Number of atomics.
 !>  @param[in] random_state  Optional random state, can be NULL if not used.
 !>  @param[in] name          Name for the kernel.
 !>  @param[in] num_particles Number of elements to operate on.
 !-------------------------------------------------------------------------------
          SUBROUTINE graph_add_pre_item(c, inputs, num_inputs,                  &
                                        outputs, num_outputs,                   &
                                        map_inputs, map_outputs, num_maps,      &
+                                       atomics, num_atomics,                   &
                                        random_state, name, num_particles)      &
          BIND(C, NAME='graph_add_pre_item')
          USE, INTRINSIC :: ISO_C_BINDING
@@ -761,6 +766,8 @@ SUBROUTINE graph_add_pre_item(c, inputs, num_inputs,                  &
          INTEGER(C_INTPTR_T), VALUE           :: map_inputs
          INTEGER(C_INTPTR_T), VALUE           :: map_outputs
          INTEGER(C_LONG), VALUE               :: num_maps
+         INTEGER(C_INTPTR_T), VALUE           :: atomics
+         INTEGER(C_LONG), VALUE               :: num_atomics
          TYPE(C_PTR), VALUE                   :: random_state
          CHARACTER(kind=C_CHAR), DIMENSION(*) :: name
          INTEGER(C_LONG), VALUE               :: num_particles
@@ -777,13 +784,16 @@ SUBROUTINE graph_add_pre_item(c, inputs, num_inputs,                  &
 !>  @param[in] map_inputs    Array of map input nodes.
 !>  @param[in] map_outputs   Array of map output nodes.
 !>  @param[in] num_maps      Number of maps.
+!>  @param[in] atomics       Array of atomics nodes.
+!>  @param[in] num_atomics   Number of atomics.
 !>  @param[in] random_state  Optional random state, can be NULL if not used.
 !>  @param[in] name          Name for the kernel.
 !>  @param[in] num_particles Number of elements to operate on.
 !-------------------------------------------------------------------------------
          SUBROUTINE graph_add_item(c, inputs, num_inputs,                      &
                                    outputs, num_outputs,                       &
                                    map_inputs, map_outputs, num_maps,          &
+                                   atomics, num_atomics,                       &
                                    random_state, name, num_particles)          &
          BIND(C, NAME='graph_add_item')
          USE, INTRINSIC :: ISO_C_BINDING
@@ -796,6 +806,8 @@ SUBROUTINE graph_add_item(c, inputs, num_inputs,                      &
          INTEGER(C_INTPTR_T), VALUE           :: map_inputs
          INTEGER(C_INTPTR_T), VALUE           :: map_outputs
          INTEGER(C_LONG), VALUE               :: num_maps
+         INTEGER(C_INTPTR_T), VALUE           :: atomics
+         INTEGER(C_LONG), VALUE               :: num_atomics
          TYPE(C_PTR), VALUE                   :: random_state
          CHARACTER(kind=C_CHAR), DIMENSION(*) :: name
          INTEGER(C_LONG), VALUE               :: num_particles
@@ -812,6 +824,8 @@ SUBROUTINE graph_add_item(c, inputs, num_inputs,                      &
 !>  @param[in] map_inputs    Array of map input nodes.
 !>  @param[in] map_outputs   Array of map output nodes.
 !>  @param[in] num_maps      Number of maps.
+!>  @param[in] atomics       Array of atomics nodes.
+!>  @param[in] num_atomics   Number of atomics.
 !>  @param[in] random_state  Optional random state, can be NULL if not used.
 !>  @param[in] name          Name for the kernel.
 !>  @param[in] num_particles Number of elements to operate on.
@@ -821,6 +835,7 @@ SUBROUTINE graph_add_item(c, inputs, num_inputs,                      &
          SUBROUTINE graph_add_converge_item(c, inputs, num_inputs,             &
                                             outputs, num_outputs,              &
                                             map_inputs, map_outputs, num_maps, &
+                                            atomics, num_atomics,              &
                                             random_state, name, num_particles, &
                                             tol, max_iter)                     &
          BIND(C, NAME='graph_add_converge_item')
@@ -834,6 +849,8 @@ SUBROUTINE graph_add_converge_item(c, inputs, num_inputs,             &
          INTEGER(C_INTPTR_T), VALUE           :: map_inputs
          INTEGER(C_INTPTR_T), VALUE           :: map_outputs
          INTEGER(C_LONG), VALUE               :: num_maps
+         INTEGER(C_INTPTR_T), VALUE           :: atomics
+         INTEGER(C_LONG), VALUE               :: num_atomics
          TYPE(C_PTR), VALUE                   :: random_state
          CHARACTER(kind=C_CHAR), DIMENSION(*) :: name
          INTEGER(C_LONG), VALUE               :: num_particles
@@ -1588,20 +1605,23 @@ FUNCTION graph_context_atan(this, left, right)
 !>  @brief Get random size.
 !>
 !>  @param[in,out] this @ref graph_context instance.
+!>  @param[in]     size Number of random numbers needed.
 !>  @param[in]     seed Initial random seed.
 !>  @returns The random size.
 !-------------------------------------------------------------------------------
-      FUNCTION graph_context_random_state(this, seed)
+      FUNCTION graph_context_random_state(this, size, seed)
 
       IMPLICIT NONE
 
 !  Declare Arguments
       TYPE(C_PTR)                         :: graph_context_random_state
       CLASS(graph_context), INTENT(INOUT) :: this
+      INTEGER(C_LONG), INTENT(IN)         :: size
       INTEGER(C_INT32_T), INTENT(IN)      :: seed
 
 !  Start of executable.
-      graph_context_random_state = graph_random_state(this%c_context, seed)
+      graph_context_random_state = graph_random_state(this%c_context,          &
+                                                      size, seed)
 
       END FUNCTION
 
@@ -2030,13 +2050,15 @@ SUBROUTINE graph_context_set_device_number(this, num)
 !>  @param[in]     outputs       Array of output nodes.
 !>  @param[in]     map_inputs    Array of map input nodes.
 !>  @param[in]     map_outputs   Array of map output nodes.
+!>  @param[in]     atomics       Array of atomic nodes.
 !>  @param[in]     random_state  Optional random state, can be NULL if not used.
 !>  @param[in]     name          Name for the kernel.
 !>  @param[in]     num_particles Number of elements to operate on.
 !-------------------------------------------------------------------------------
       SUBROUTINE graph_context_add_pre_item(this, inputs, outputs,             &
                                             map_inputs, map_outputs,           &
-                                            random_state, name, num_particles)
+                                            atomics, random_state, name,       &
+                                            num_particles)
 
       IMPLICIT NONE
 
@@ -2046,6 +2068,7 @@ SUBROUTINE graph_context_add_pre_item(this, inputs, outputs,             &
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: outputs
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: map_inputs
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: map_outputs
+      INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: atomics
       TYPE(C_PTR), INTENT(IN)                       :: random_state
       CHARACTER(kind=C_CHAR,len=*), INTENT(IN)      :: name
       INTEGER(C_LONG), INTENT(IN)                   :: num_particles
@@ -2056,6 +2079,8 @@ SUBROUTINE graph_context_add_pre_item(this, inputs, outputs,             &
                               LOC(outputs), INT(SIZE(outputs), KIND=C_LONG),   &
                               LOC(map_inputs), LOC(map_outputs),               &
                               INT(SIZE(map_inputs), KIND=C_LONG),              &
+                              LOC(atomics),                                    &
+                              INT(SIZE(atomics), KIND=C_LONG),                 &
                               random_state, name, num_particles)
 
       END SUBROUTINE
@@ -2068,13 +2093,15 @@ SUBROUTINE graph_context_add_pre_item(this, inputs, outputs,             &
 !>  @param[in]     outputs       Array of output nodes.
 !>  @param[in]     map_inputs    Array of map input nodes.
 !>  @param[in]     map_outputs   Array of map output nodes.
+!>  @param[in]     atomics       Array of atomic nodes.
 !>  @param[in]     random_state  Optional random state, can be NULL if not used.
 !>  @param[in]     name          Name for the kernel.
 !>  @param[in]     num_particles Number of elements to operate on.
 !-------------------------------------------------------------------------------
       SUBROUTINE graph_context_add_item(this, inputs, outputs,                 &
                                         map_inputs, map_outputs,               &
-                                        random_state, name, num_particles)
+                                        atomics, random_state, name,           &
+                                        num_particles)
 
       IMPLICIT NONE
 
@@ -2084,6 +2111,7 @@ SUBROUTINE graph_context_add_item(this, inputs, outputs,                 &
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: outputs
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: map_inputs
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: map_outputs
+      INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: atomics
       TYPE(C_PTR), INTENT(IN)                       :: random_state
       CHARACTER(kind=C_CHAR,len=*), INTENT(IN)      :: name
       INTEGER(C_LONG), INTENT(IN)                   :: num_particles
@@ -2094,6 +2122,8 @@ SUBROUTINE graph_context_add_item(this, inputs, outputs,                 &
                           LOC(outputs), INT(SIZE(outputs), KIND=C_LONG),       &
                           LOC(map_inputs), LOC(map_outputs),                   &
                           INT(SIZE(map_inputs), KIND=C_LONG),                  &
+                          LOC(atomics),                                        &
+                          INT(SIZE(atomics), KIND=C_LONG),                     &
                           random_state, name, num_particles)
 
       END SUBROUTINE
@@ -2106,6 +2136,7 @@ SUBROUTINE graph_context_add_item(this, inputs, outputs,                 &
 !>  @param[in]     outputs       Array of output nodes.
 !>  @param[in]     map_inputs    Array of map input nodes.
 !>  @param[in]     map_outputs   Array of map output nodes.
+!>  @param[in]     atomics       Array of atomic nodes.
 !>  @param[in]     random_state  Optional random state, can be NULL if not used.
 !>  @param[in]     name          Name for the kernel.
 !>  @param[in]     num_particles Number of elements to operate on.
@@ -2114,7 +2145,7 @@ SUBROUTINE graph_context_add_item(this, inputs, outputs,                 &
 !-------------------------------------------------------------------------------
       SUBROUTINE graph_context_add_converge_item(this, inputs, outputs,        &
                                                  map_inputs, map_outputs,      &
-                                                 random_state, name,           &
+                                                 atomics, random_state, name,  &
                                                  num_particles, tol, max_iter)
 
       IMPLICIT NONE
@@ -2125,6 +2156,7 @@ SUBROUTINE graph_context_add_converge_item(this, inputs, outputs,        &
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: outputs
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: map_inputs
       INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: map_outputs
+      INTEGER(C_INTPTR_T), DIMENSION(:), INTENT(IN) :: atomics
       TYPE(C_PTR), INTENT(IN)                       :: random_state
       CHARACTER(kind=C_CHAR,len=*), INTENT(IN)      :: name
       INTEGER(C_LONG), INTENT(IN)                   :: num_particles
@@ -2138,6 +2170,8 @@ SUBROUTINE graph_context_add_converge_item(this, inputs, outputs,        &
                                    INT(SIZE(outputs), KIND=C_LONG),            &
                                    LOC(map_inputs), LOC(map_outputs),          &
                                    INT(SIZE(map_inputs), KIND=C_LONG),         &
+                                   LOC(atomics),                               &
+                                   INT(SIZE(atomics), KIND=C_LONG),            &
                                    random_state, name, num_particles,          &
                                    tol, max_iter)