nested-fit 5.8.0.dev133__tar.gz → 6.0.0.dev136__tar.gz

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nested_fit
-Version: 5.8.0.dev133
+Version: 6.0.0.dev136
 Summary: The nested_fit package.
 Author: Martino Trassinelli, Lune Maillard, César Godinho
 Project-URL: Homepage, https://github.com/martinit18/nested_fit
@@ -84,8 +84,8 @@ pipx install nested_fit
 
 With an NVIDIA GPU, `pipx install "nested_fit[cuda]"` adds the runtime compiler the GPU backend
 needs; the driver is the only other requirement, no CUDA toolkit. The likelihood then runs on
-the GPU when that is faster than the CPU threads together, and on the CPU otherwise, with one
-log line saying which. Details and controls in `src/gpu/README.md`.
+the GPU, on at most 8 threads, whenever a startup self-test finds that faster than all the CPU
+threads together, and on the CPU otherwise, with one log line saying which. Details and controls in `src/gpu/README.md`.
 
 The `examples/` directory is bundled with the package. After installation you can
 copy it to a local working area in a couple of ways:
@@ -453,7 +453,7 @@ Examples of use of a legacy function can be found in `examples/data_analysis/aaa
 
 ## Present version and history of the past versions
 
-The present version is 5.8.0\
+The present version is 6.0.0\
 New features:
 - Asynchronous parallel search of new points: each thread adds its new point to the main loop without waiting for the search of the other threads.
 This strongly improves the parallel efficiency when the search time of new points is very variable (e.g. Lennard-Jones clusters)

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/README.md

@@ -57,8 +57,8 @@ pipx install nested_fit
 
 With an NVIDIA GPU, `pipx install "nested_fit[cuda]"` adds the runtime compiler the GPU backend
 needs; the driver is the only other requirement, no CUDA toolkit. The likelihood then runs on
-the GPU when that is faster than the CPU threads together, and on the CPU otherwise, with one
-log line saying which. Details and controls in `src/gpu/README.md`.
+the GPU, on at most 8 threads, whenever a startup self-test finds that faster than all the CPU
+threads together, and on the CPU otherwise, with one log line saying which. Details and controls in `src/gpu/README.md`.
 
 The `examples/` directory is bundled with the package. After installation you can
 copy it to a local working area in a couple of ways:
@@ -426,7 +426,7 @@ Examples of use of a legacy function can be found in `examples/data_analysis/aaa
 
 ## Present version and history of the past versions
 
-The present version is 5.8.0\
+The present version is 6.0.0\
 New features:
 - Asynchronous parallel search of new points: each thread adds its new point to the main loop without waiting for the search of the other threads.
 This strongly improves the parallel efficiency when the search time of new points is very variable (e.g. Lennard-Jones clusters)

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/nested_fit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nested_fit
-Version: 5.8.0.dev133
+Version: 6.0.0.dev136
 Summary: The nested_fit package.
 Author: Martino Trassinelli, Lune Maillard, César Godinho
 Project-URL: Homepage, https://github.com/martinit18/nested_fit
@@ -84,8 +84,8 @@ pipx install nested_fit
 
 With an NVIDIA GPU, `pipx install "nested_fit[cuda]"` adds the runtime compiler the GPU backend
 needs; the driver is the only other requirement, no CUDA toolkit. The likelihood then runs on
-the GPU when that is faster than the CPU threads together, and on the CPU otherwise, with one
-log line saying which. Details and controls in `src/gpu/README.md`.
+the GPU, on at most 8 threads, whenever a startup self-test finds that faster than all the CPU
+threads together, and on the CPU otherwise, with one log line saying which. Details and controls in `src/gpu/README.md`.
 
 The `examples/` directory is bundled with the package. After installation you can
 copy it to a local working area in a couple of ways:
@@ -453,7 +453,7 @@ Examples of use of a legacy function can be found in `examples/data_analysis/aaa
 
 ## Present version and history of the past versions
 
-The present version is 5.8.0\
+The present version is 6.0.0\
 New features:
 - Asynchronous parallel search of new points: each thread adds its new point to the main loop without waiting for the search of the other threads.
 This strongly improves the parallel efficiency when the search time of new points is very variable (e.g. Lennard-Jones clusters)

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nested_fit"
-version = "5.8.0.dev133"
+version = "6.0.0.dev136"
 description = "The nested_fit package."
 readme = "README.md"
 
@@ -52,7 +52,8 @@ nested_fit = "pynested_fit.cliw:main"
 build = "cp*"
 
 # Force old toolchain (we don't use anything that requires glibc >= 2.17 dynamically)
-manylinux-x86_64-image = "manylinux2014"
+# manylinux_2_28 (glibc >= 2.28, 2018): its GCC 14 can link libquadmath statically, see [tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
 
 # Now statically link to libgcc / stdlib / libgfortran
 environment = "CFLAGS='-static-libgcc -static-libstdc++' CXXFLAGS='-static-libgcc -static-libstdc++' FFLAGS='-static-libgfortran'"
@@ -67,9 +68,11 @@ archs = ["x86_64", "arm64"]
 
 [tool.cibuildwheel.linux]
 archs = ["x86_64"]
+# libquadmath static too: the executable then needs no bundled library, so auditwheel's patchelf never rewrites it (it corrupted it: the nightly wheels segfaulted at startup).
+environment = "CFLAGS='-static-libgcc -static-libstdc++' CXXFLAGS='-static-libgcc -static-libstdc++' FFLAGS='-static-libgfortran -static-libquadmath'"
 
 [tool.setuptools_scm]
-fallback_version = "5.8.0.dev133"
+fallback_version = "6.0.0.dev136"
 
 [options]
 python_requires = ">=3.8"

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/src/Mod_gpu.f90

@@ -6,6 +6,8 @@ MODULE MOD_GPU
   LOGICAL :: gpu_on = .FALSE.
   INTEGER :: gpu_threads = -1   ! threads 0..gpu_threads-1 evaluate on the device, the rest on the CPU; -1 = all
   LOGICAL :: gpu_mixed = .FALSE.    ! per-term precision: NF_TERM terms in single, the large ones in double
+  LOGICAL :: gpu_precision_auto = .FALSE.   ! the precision was chosen from the model (search.gpu_precision: auto)
+  LOGICAL :: gpu_threads_auto = .FALSE.     ! the thread split is left to the self-test (search.gpu_threads: -1)
   CHARACTER(LEN=16) :: gpu_pref = 'auto'   ! the device preference in force: NESTED_FIT_DEVICE, else search.device
 
   INTERFACE
@@ -119,6 +121,9 @@ CONTAINS
     prec = precision_pref
     CALL GET_ENVIRONMENT_VARIABLE('NESTED_FIT_GPU_PRECISION', env, STATUS=st)
     IF (st == 0 .AND. LEN_TRIM(env) > 0) prec = env
+    gpu_precision_auto = (prec(1:1) == 'a' .OR. prec(1:1) == 'A')
+    ! auto: a model that marks its additive terms with NF_TERM asked for per-term precision
+    IF (gpu_precision_auto) prec = MERGE('mixed ', 'double', INDEX(c_body, 'NF_TERM') > 0)
     gpu_mixed = (prec(1:1) == 'm' .OR. prec(1:1) == 'M')
     CALL nf_gpu_set_precision(TRIM(prec)//c_null_char)
     IF (nf_gpu_set_function(TRIM(c_body)//c_null_char, TRIM(param_ids)//c_null_char, npar) /= 0) THEN
@@ -129,6 +134,7 @@ CONTAINS
     gpu_threads = threads_pref
     CALL GET_ENVIRONMENT_VARIABLE('NESTED_FIT_GPU_THREADS', env, STATUS=st)
     IF (st == 0) READ(env, *, IOSTAT=st) gpu_threads
+    gpu_threads_auto = (gpu_threads < 0)
     IF (gpu_threads == 0) THEN
       why = 'gpu_threads = 0'
       CALL nf_gpu_free()

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/src/Mod_likelihood.f90

@@ -19,7 +19,7 @@ MODULE MOD_LIKELIHOOD
   
   ! String manipulation
   USE MOD_STRUTIL
-  USE MOD_GPU, ONLY: gpu_on, gpu_threads, gpu_mixed, gpu_pref, nf_gpu_loglike, nf_gpu_device_name, GPU_SETUP, C_STR, READ_TEXT_FILE
+  USE MOD_GPU, ONLY: gpu_on, gpu_threads, gpu_mixed, gpu_pref, gpu_precision_auto, gpu_threads_auto, nf_gpu_loglike, nf_gpu_device_name, GPU_SETUP, C_STR, READ_TEXT_FILE
   !$ USE omp_lib, ONLY: omp_get_thread_num
 
   !$ USE OMP_LIB
@@ -376,15 +376,12 @@ CONTAINS
        CALL GPU_SETUP(x(1:n,1), nc(1:n,1), nc(1:n,1), n, like_kind, nth, src, gpu_param_ids, n_par, why, opt_device, opt_gpu_min_points, opt_gpu_threads, opt_gpu_precision)
     END IF
     IF (gpu_on) THEN
-       IF (gpu_threads > 0 .AND. gpu_threads < nth) THEN
-          WRITE(why, '(a,i0,a,i0,a)') ' on ', gpu_threads, ' of ', nth, ' threads, the others on the CPU'
-       ELSE
-          why = ''
-       END IF
+       why = ''
+       IF (gpu_precision_auto) why = ', chosen from the model'
        IF (gpu_mixed) THEN
-          CALL LOG_MESSAGE('GPU: likelihood on '//TRIM(C_STR(nf_gpu_device_name()))//' (per-term mixed precision: NF_TERM in single, large terms in double)'//TRIM(why))
+          CALL LOG_MESSAGE('GPU: '//TRIM(C_STR(nf_gpu_device_name()))//' found; per-term mixed precision (NF_TERM terms in single, the large ones in double'//TRIM(why)//')')
        ELSE
-          CALL LOG_MESSAGE('GPU: likelihood on '//TRIM(C_STR(nf_gpu_device_name()))//' (double precision)'//TRIM(why))
+          CALL LOG_MESSAGE('GPU: '//TRIM(C_STR(nf_gpu_device_name()))//' found; double precision'//TRIM(why))
        END IF
        CALL GPU_SELF_TEST()
     ELSE
@@ -398,7 +395,8 @@ CONTAINS
     ! per-term mixed to 1e-6, or the device is refused. Also the first measurement a user sees:
     ! one evaluation on the device against one CPU thread.
     REAL(8), DIMENSION(npar) :: p
-    REAL(8) :: cpu, dev, t_cpu, t_dev, worst, tol
+    REAL(8) :: cpu, dev, t_cpu, t_dev, worst, tol, r
+    INTEGER, PARAMETER :: streams_max = 8   ! threads the run keeps when the GPU is used: 8 saturate an RTX A4000 in per-term precision (2 do not, 128 are 2.3x slower)
     INTEGER(8) :: t0, t1, rate
     INTEGER :: k
     CHARACTER(LEN=16) :: name
@@ -424,21 +422,45 @@ CONTAINS
     WRITE(msg, '(a,a,a,es8.1,a,es9.2,a,es9.2,a,f8.1,a)') 'GPU: self-test, ', TRIM(name), ': max relative difference to the CPU ', worst, &
          '; one evaluation ', t_dev*1d3, ' ms on the device, ', t_cpu*1d3, ' ms on one CPU thread (', t_cpu/t_dev, 'x)'
     CALL LOG_MESSAGE(TRIM(msg))
-    ! The decision "install and it decides": with device = auto the card is used only when it
-    ! beats the CPU threads together. One evaluation per launch costs ~20 us on the host side,
-    ! so a cheap model on a few thousand points is faster on the cores (measured: every example
-    ! of the suite), and a heavy one is faster on the card by 20-200x (measured: a 284-term Voigt
-    ! model on 16 501 points). The ratio of the two self-test timings, against the thread count,
-    ! is that boundary; search.device = cuda/hip (or NESTED_FIT_DEVICE) forces the card regardless.
-    IF (TRIM(gpu_pref) == 'auto' .AND. t_cpu/t_dev < DBLE(nth)) THEN
+    ! The decision "install and it decides". One launch costs ~20 us on the host side, so a cheap
+    ! model on a few thousand points is faster on the cores (measured: every example of the suite)
+    ! and a heavy one is faster on the GPU by 20-200x per evaluation (measured: a 284-term Voigt
+    ! model on 16 501 points). r = the ratio of the two self-test timings, one evaluation on one
+    ! CPU thread over one on the GPU. With search.gpu_threads left to -1:
+    !   4 r < nth   the GPU, fed by 8 threads, does not beat the CPU threads together (8 streams
+    !               deliver about half their nominal rate on a workstation GPU): not used;
+    !               search.device: cuda forces it
+    !   otherwise   the run keeps MIN(nth, 8) threads, all of them on the GPU. More host threads
+    !               only add in-flight evaluations (128 threads on the GPU: 2.3x slower than 8),
+    !               and CPU threads beside the GPU threads starve them (8 on the GPU + 120 on the
+    !               CPU: 6x slower than 8 alone), both measured on an EPYC 7452 with an RTX A4000.
+    ! An explicit gpu_threads is kept as given: that many on the GPU, the others on the CPU.
+    r = t_cpu/t_dev
+    IF (gpu_threads_auto) THEN
+       IF (TRIM(gpu_pref) /= 'auto' .OR. 4d0*r >= DBLE(nth)) THEN
+          nth = MIN(nth, streams_max)
+          gpu_threads = nth
+       ELSE
+          gpu_threads = 0
+       END IF
+    END IF
+    IF (gpu_threads == 0) THEN
        gpu_on = .FALSE.
-       WRITE(msg, '(a,es9.2,a,es9.2,a,i0,a)') 'GPU: not used (one evaluation ', t_dev*1d3, ' ms on the device vs ', t_cpu*1d3, &
-            ' ms on one CPU thread: the ', nth, ' CPU threads are faster together; search.device: cuda forces the card)'
+       WRITE(msg, '(a,es9.2,a,es9.2,a,f7.1,a,i0,a)') 'GPU: not used (one evaluation ', t_dev*1d3, ' ms on the GPU vs ', t_cpu*1d3, &
+            ' ms on one CPU thread, ', r, 'x: fed by 8 threads it does not beat the ', nth, ' CPU threads together; search.device: cuda forces it)'
        CALL LOG_MESSAGE(TRIM(msg))
     ELSE IF (worst > tol .OR. worst /= worst) THEN
        gpu_on = .FALSE.
        WRITE(msg, '(a,a,a,es8.1,a)') 'GPU: not used (self-test failed: ', TRIM(name), ' precision differs from the CPU by more than ', tol, ' in log L)'
        CALL LOG_MESSAGE(TRIM(msg))
+    ELSE IF (gpu_threads < nth) THEN
+       WRITE(msg, '(a,i0,a,i0,a,f7.1,a,i0,a)') 'GPU: used on ', gpu_threads, ' of ', nth, ' threads (one evaluation ', r, &
+            'x one CPU thread); the other ', nth - gpu_threads, ' threads stay on the CPU'
+       CALL LOG_MESSAGE(TRIM(msg))
+    ELSE
+       WRITE(msg, '(a,i0,a,f7.1,a)') 'GPU: used; the run keeps ', nth, ' threads, all on the GPU (one evaluation ', r, &
+            'x one CPU thread; more host threads were measured slower)'
+       CALL LOG_MESSAGE(TRIM(msg))
     END IF
   END SUBROUTINE GPU_SELF_TEST
 

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/src/Mod_options.f90

@@ -22,12 +22,14 @@ MODULE MOD_OPTIONS
     ! function, compiled for the device at run time. params[i] is the parameter with npar = i+1.
     CHARACTER(LEN=512) :: opt_gpu_source = ''
     ! `search.gpu_threads`: how many of the OpenMP threads evaluate on the device; the others
-    ! use the CPU, so both are busy. -1 (default) = all of them.
+    ! use the CPU, so both are busy. -1 (default): decided by the startup self-test, which keeps
+    ! at most 8 threads, all on the GPU, when it uses the GPU (GPU_SELF_TEST).
     INTEGER :: opt_gpu_threads = -1
-    ! `search.gpu_precision`: 'double' (default: the CPU's closed forms, the CPU's bits) or
-    ! 'mixed' (per-term: NF_TERM terms in float, the large ones in double; 7-10x the double
-    ! rate on consumer and workstation cards). Env NESTED_FIT_GPU_PRECISION overrides.
-    CHARACTER(LEN=16) :: opt_gpu_precision = 'double'
+    ! `search.gpu_precision`: 'auto' (default: 'mixed' when the model marks its terms with
+    ! NF_TERM, 'double' otherwise), 'double' (the CPU's closed forms, the CPU's bits) or 'mixed'
+    ! (per-term: NF_TERM terms in float, the large ones in double; 7-10x the double rate on
+    ! consumer and workstation GPUs). Env NESTED_FIT_GPU_PRECISION overrides.
+    CHARACTER(LEN=16) :: opt_gpu_precision = 'auto'
     
     CHARACTER(LEN=512) :: opt_cpp_comp_cmd = 'g++ -c -shared -O3 -w -fPIC'
     CHARACTER(LEN=512) :: opt_f90_comp_cmd = 'gfortran -cpp -c -shared -O3 -w -fPIC -ffree-line-length-0'

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/src/gpu/README.md

@@ -58,7 +58,8 @@ is the same work as writing the Fortran was.
 
 **Precision.** `search.gpu_precision` (env `NESTED_FIT_GPU_PRECISION`):
 
-* `double` (default): the CPU's closed forms, the CPU's bits.
+* `auto` (default): `mixed` when the model marks its terms with `NF_TERM`, `double` otherwise.
+* `double`: the CPU's closed forms, the CPU's bits.
 * `mixed`: per-term precision. A model written with `NF_TERM(multiplier, function, args...)`
   around its additive terms has each term evaluated in single precision and recomputed in
   double only when it exceeds a tenth of the data's noise at that point
@@ -70,19 +71,24 @@ is the same work as writing the Fortran was.
   dependent, and far more than the evidence tolerates.
 
 **Threads.** `search.gpu_threads` (env `NESTED_FIT_GPU_THREADS`): how many of the OpenMP
-threads evaluate on the device; the others keep the CPU closed forms, so both are busy. -1
-(default) sends every thread to the GPU. A workstation GPU serialises the launches of many
-host threads: on an RTX A4000 two device threads evaluate 108 times per second where eight
-evaluate 83, so `gpu_threads: 2` with the remaining threads on 46 cores is 1.47× the GPU
-alone in double; in per-term precision the cores add about a tenth.
+threads evaluate on the GPU; the others keep the CPU closed forms. -1 (default) leaves the choice
+to the startup self-test, from r = one evaluation on one CPU thread over one on the GPU: when
+4 r < threads the GPU is not used, otherwise the run keeps at most 8 threads, all of them on the
+GPU. Measured on an EPYC 7452 (128 threads) with an RTX A4000, per-term precision, 100 steps of
+the Voigt model: 8 threads on the GPU 26 s; 128 threads on the GPU 60 s (more in-flight
+evaluations, 93 ms per launch); 8 on the GPU and 120 on the CPU over 900 s (the CPU threads starve
+the ones feeding the GPU). An explicit number is kept as given, that many on the GPU and the rest
+on the CPU: `gpu_threads: 2` with the other threads on the cores was 1.47× the GPU alone in double
+precision on an 8-thread host, and is a setting, not a default.
 
 **Startup self-test.** When a device is used, the likelihood is evaluated on both backends at
 three points of the prior box before sampling starts. The log reports the largest relative
 difference and the time of one evaluation on the device against one CPU thread; above 10⁻⁸
 in double, or 10⁻⁶ in per-term mixed precision, the device is refused and the run continues
 on the CPU. A wrong port of a user function cannot reach the evidence. With `device: auto` the
-GPU is also refused when one evaluation on it is not faster than the CPU threads together
-(a cheap model on a few thousand points: every example of the suite); `device: cuda` forces it.
+GPU is also refused when, fed by 8 threads, it would not beat the CPU threads together, i.e. when
+4 r < threads (a cheap model on a few thousand points: every example of the suite); otherwise the
+run keeps at most 8 threads, all on the GPU (see Threads); `device: cuda` forces the GPU.
 
 One parameter vector per launch: about break-even with a CPU thread at ~1000 data points of a
 cheap model, growing with data size and with the cost per point. Batching the search's
@@ -97,8 +103,8 @@ its `nf_input.yaml` alone, and `nf_output_res.json` records `input.search.device
 search:
   device:         auto     # auto (default) | cuda | hip | cpu
   gpu_min_points: 0        # use the GPU only above this many data points
-  gpu_threads:    -1       # threads that evaluate on the device (-1: all), the others on the CPU
-  gpu_precision:  double   # double (default) | mixed (per-term, NF_TERM)
+  gpu_threads:    -1       # -1 (default): the self-test keeps at most 8 threads, all on the GPU; N: N on the GPU, the others on the CPU
+  gpu_precision:  auto     # auto (default: mixed if the model uses NF_TERM) | double | mixed
 ```
 
 Environment variables override the file (useful for sweeps without editing it):

{nested_fit-5.8.0.dev133 → nested_fit-6.0.0.dev136}/src/nested_fit.f90

@@ -424,8 +424,8 @@ PROGRAM NESTED_FIT
   CALL FIELD_FROM_INPUT_CHARACTER(input_config, 'search.device'    , opt_device   , MANDATORY=.FALSE.) ! 'auto' by default: GPU if present, else CPU
   CALL FIELD_FROM_INPUT_INTEGER  (input_config, 'search.gpu_min_points', opt_gpu_min_points, MANDATORY=.FALSE.) ! 0 by default
   CALL FIELD_FROM_INPUT_CHARACTER(input_config, 'function.gpu_source'  , opt_gpu_source  , MANDATORY=.FALSE.) ! device source of a legacy user function
-  CALL FIELD_FROM_INPUT_INTEGER  (input_config, 'search.gpu_threads'   , opt_gpu_threads , MANDATORY=.FALSE.) ! -1 by default: every thread uses the device
-  CALL FIELD_FROM_INPUT_CHARACTER(input_config, 'search.gpu_precision' , opt_gpu_precision, MANDATORY=.FALSE.) ! 'double' by default
+  CALL FIELD_FROM_INPUT_INTEGER  (input_config, 'search.gpu_threads'   , opt_gpu_threads , MANDATORY=.FALSE.) ! -1 by default: the self-test decides
+  CALL FIELD_FROM_INPUT_CHARACTER(input_config, 'search.gpu_precision' , opt_gpu_precision, MANDATORY=.FALSE.) ! 'auto' by default
   CALL FIELD_FROM_INPUT_LOGICAL  (input_config, 'search.hard_writing'  , hard_writing_parameters  , MANDATORY=.FALSE.) ! True by default
   CALL FIELD_FROM_INPUT_INTEGER  (input_config, 'search.max_steps' , maxstep_try  , MANDATORY=.NOT.hard_writing_parameters) ! 100000 by default, mandatory if not hard writing parameters