Merge pull request #19515 from jenshannoschwalm/safe_lowmem_systems

Safe lowmem systems

Author: TurboGit

src/common/darktable.c

@@ -546,7 +546,7 @@ static size_t _get_mipmap_size()
   dt_sys_resources_t *res = &darktable.dtresources;
   const int level = res->level;
   if(level < 0)
-    return res->refresource[4*(-level-1) + 2] * 1024lu * 1024lu;
+    return res->refresource[4*(-level-1) + 2] * DT_MEGA;
   const int fraction = res->fractions[4*level + 2];
   return res->total_memory / 1024lu * fraction;
 }
@@ -1169,6 +1169,7 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
         CHKSIGDBG(DT_SIGNAL_CONTROL_TOAST_REDRAW);
         CHKSIGDBG(DT_SIGNAL_CONTROL_PICKERDATA_READY);
         CHKSIGDBG(DT_SIGNAL_METADATA_UPDATE);
+        CHKSIGDBG(DT_SIGNAL_PRESET_APPLIED);
         else
         {
           dt_print(DT_DEBUG_SIGNAL,
@@ -1694,7 +1695,9 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
   dt_sys_resources_t *res = &darktable.dtresources;
   res->fractions = fractions;
   res->refresource = ref_resources;
-  res->total_memory = _get_total_memory() * 1024lu;
+  size_t total_mb = _get_total_memory() / 1024lu;
+  if(total_mb < 8192) total_mb -= 1024;
+  res->total_memory = total_mb * DT_MEGA;
 
   char *config_info = calloc(1, DT_PERF_INFOSIZE);
   if(last_configure_version != DT_CURRENT_PERFORMANCE_CONFIGURE_VERSION
@@ -1706,7 +1709,7 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
   dt_get_sysresource_level();
   res->mipmap_memory = _get_mipmap_size();
   dt_print(DT_DEBUG_MEMORY | DT_DEBUG_DEV,
-    "  mipmap cache:    %luMB", res->mipmap_memory / 1024lu / 1024lu);
+    "  mipmap cache:    %luMB", res->mipmap_memory / DT_MEGA);
   // initialize collection query
   darktable.collection = dt_collection_new(NULL);
 
@@ -2007,11 +2010,11 @@ void dt_get_sysresource_level()
     dt_print(DT_DEBUG_MEMORY | DT_DEBUG_DEV,
              "[dt_get_sysresource_level] switched to `%s'", config);
     dt_print(DT_DEBUG_MEMORY | DT_DEBUG_DEV,
-             "  total mem:       %luMB", res->total_memory / 1024lu / 1024lu);
+             "  total mem:       %luMB", res->total_memory / DT_MEGA);
     dt_print(DT_DEBUG_MEMORY | DT_DEBUG_DEV,
-             "  available mem:   %luMB", dt_get_available_mem() / 1024lu / 1024lu);
+             "  available mem:   %luMB", dt_get_available_mem() / DT_MEGA);
     dt_print(DT_DEBUG_MEMORY | DT_DEBUG_DEV,
-             "  singlebuff:      %luMB", dt_get_singlebuffer_mem() / 1024lu / 1024lu);
+             "  singlebuff:      %luMB", dt_get_singlebuffer_mem() / DT_MEGA);
   }
 }
 
@@ -2340,27 +2343,27 @@ size_t dt_get_available_mem()
   dt_sys_resources_t *res = &darktable.dtresources;
   const int level = res->level;
   if(level < 0)
-    return res->refresource[4*(-level-1)] * 1024lu * 1024lu;
+    return res->refresource[4*(-level-1)] * DT_MEGA;
 
   const int fraction = res->fractions[4*level];
-  return MAX(512lu * 1024lu * 1024lu, res->total_memory / 1024lu * fraction);
+  return MAX(512lu * DT_MEGA, res->total_memory / 1024lu * fraction);
 }
 
 size_t dt_get_singlebuffer_mem()
 {
   dt_sys_resources_t *res = &darktable.dtresources;
   const int level = res->level;
   if(level < 0)
-    return res->refresource[4*(-level-1) + 1] * 1024lu * 1024lu;
+    return res->refresource[4*(-level-1) + 1] * DT_MEGA;
 
   const int fraction = res->fractions[4*level + 1];
-  return MAX(2lu * 1024lu * 1024lu, res->total_memory / 1024lu * fraction);
+  return MAX(2lu * DT_MEGA, res->total_memory / 1024lu * fraction);
 }
 
 void dt_configure_runtime_performance(const int old, char *info)
 {
   const size_t threads = dt_get_num_procs();
-  const size_t mem = darktable.dtresources.total_memory / 1024lu / 1024lu;
+  const size_t mem = darktable.dtresources.total_memory / DT_MEGA;
   const size_t bits = CHAR_BIT * sizeof(void *);
   const gboolean sufficient = mem >= 4096 && threads >= 2;
 

src/common/math.h

@@ -25,6 +25,8 @@
 
 #define LUT_ELEM 512 // gamut LUT number of elements:
 
+#define DT_MEGA 1048576lu
+
 #define NORM_MIN 1.52587890625e-05f // norm can't be < to 2^(-16)
 
 // select speed vs accuracy tradeoff

src/common/opencl.c

@@ -781,11 +781,11 @@ static gboolean _opencl_device_init(dt_opencl_t *cl,
   (cl->dlocl->symbols->dt_clGetDeviceInfo)
     (devid, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong),
      &(cl->dev[dev].max_global_mem), NULL);
-  if(cl->dev[dev].max_global_mem < (uint64_t)800ul * 1024ul * 1024ul)
+  if(cl->dev[dev].max_global_mem < (uint64_t)800ul * DT_MEGA)
   {
     dt_print_nts(DT_DEBUG_OPENCL,
                  "   *** insufficient global memory (%" PRIu64 "MB) ***\n",
-                 cl->dev[dev].max_global_mem / 1024 / 1024);
+                 cl->dev[dev].max_global_mem / DT_MEGA);
     res = TRUE;
     cl->dev[dev].disabled |= TRUE;
     goto end;
@@ -807,10 +807,10 @@ static gboolean _opencl_device_init(dt_opencl_t *cl,
 
   dt_print_nts(DT_DEBUG_OPENCL,
                "   GLOBAL MEM SIZE:          %.0f MB\n",
-               (double)cl->dev[dev].max_global_mem / 1024.0 / 1024.0);
+               (double)cl->dev[dev].max_global_mem / (double)DT_MEGA);
   dt_print_nts(DT_DEBUG_OPENCL,
                "   MAX MEM ALLOC:            %.0f MB\n",
-               (double)cl->dev[dev].max_mem_alloc / 1024.0 / 1024.0);
+               (double)cl->dev[dev].max_mem_alloc / (double)DT_MEGA);
   dt_print_nts(DT_DEBUG_OPENCL,
                "   MAX IMAGE SIZE:           %zd x %zd\n",
                cl->dev[dev].max_image_width, cl->dev[dev].max_image_height);
@@ -3575,16 +3575,16 @@ void dt_opencl_check_tuning(const int devid)
 
   if(level < 0)
   {
-    cl->dev[devid].used_available = res->refresource[4*(-level-1) + 3] * 1024lu * 1024lu;
+    cl->dev[devid].used_available = res->refresource[4*(-level-1) + 3] * DT_MEGA;
   }
   else
   {
     const size_t allmem = cl->dev[devid].max_global_mem;
-    const size_t lowmem = 256ul * 1024ul * 1024ul;
-    const size_t dhead = DT_OPENCL_DEFAULT_HEADROOM * 1024ul * 1024ul;
+    const size_t lowmem = 256ul * DT_MEGA;
+    const size_t dhead = DT_OPENCL_DEFAULT_HEADROOM * DT_MEGA;
     if(cl->dev[devid].tunehead)
     {
-      const size_t headroom = (cl->dev[devid].headroom ? 1024ul * 1024ul * cl->dev[devid].headroom : dhead)
+      const size_t headroom = (cl->dev[devid].headroom ? DT_MEGA * cl->dev[devid].headroom : dhead)
                             + (cl->dev[devid].clmem_error ? dhead : 0);
       cl->dev[devid].used_available = allmem > headroom ? allmem - headroom : lowmem;
     }

src/develop/pixelpipe_hb.c

@@ -282,9 +282,8 @@ gboolean dt_dev_pixelpipe_init_cached(dt_dev_pixelpipe_t *pipe,
 
 size_t dt_get_available_pipe_mem(const dt_dev_pixelpipe_t *pipe)
 {
-  size_t allmem = dt_get_available_mem();
-  return MAX(1lu * 1024lu * 1024lu,
-             allmem / (pipe->type & DT_DEV_PIXELPIPE_THUMBNAIL ? 3 : 1));
+  const size_t allmem = dt_get_available_mem();
+  return MAX(DT_MEGA, allmem / (pipe->type & DT_DEV_PIXELPIPE_THUMBNAIL ? 3 : 1));
 }
 
 static void get_output_format(dt_iop_module_t *module,
@@ -3056,7 +3055,7 @@ gboolean dt_dev_pixelpipe_process(dt_dev_pixelpipe_t *pipe,
                   pipe, NULL, pipe->devid, &roi, &roi, "ID=%i, %s %luMB%s%s",
                   pipe->image.id,
                   darktable.opencl->dev[pipe->devid].cname,
-                  darktable.opencl->dev[pipe->devid].used_available / 1024lu / 1024lu,
+                  darktable.opencl->dev[pipe->devid].used_available / DT_MEGA,
                   darktable.opencl->dev[pipe->devid].tunehead ? ", tuned" : "",
                   darktable.opencl->dev[pipe->devid].pinned_memory ? ", pinned": "");
   else

src/iop/demosaic.c

@@ -52,7 +52,6 @@ DT_MODULE_INTROSPECTION(6, dt_iop_demosaic_params_t)
 #define DT_DEMOSAIC_XTRANS 1024 // masks for non-Bayer demosaic ops
 #define DT_DEMOSAIC_DUAL 2048   // masks for dual demosaicing methods
 #define DT_REDUCESIZE_MIN 64
-#define DT_MEGA 1048576l
 
 // these are highly depending on CPU architecture (cache size)
 #define DT_RCD_TILESIZE 112