Merge pull request #17718 from jenshannoschwalm/pixelpipe_memory

Pixelpipe safety improvements and maintenance

Author: TurboGit

src/common/darktable.c

@@ -1372,8 +1372,7 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
               cachedir_from_command,
               tmpdir_from_command);
 
-  dt_print(DT_DEBUG_MEMORY, "[memory] at startup");
-  dt_print_mem_usage();
+  dt_print_mem_usage("at startup");
 
   char sharedir[PATH_MAX] = { 0 };
   dt_loc_get_sharedir(sharedir, sizeof(sharedir));
@@ -1827,9 +1826,6 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
     dt_gui_process_events();
   }
 
-  dt_print(DT_DEBUG_MEMORY, "[memory] after successful startup");
-  dt_print_mem_usage();
-
 /* init lua last, since it's user made stuff it must be in the real environment */
 #ifdef USE_LUA
   darktable_splash_screen_set_progress(_("initializing Lua"));
@@ -1916,6 +1912,9 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
 
   dt_print(DT_DEBUG_CONTROL,
            "[dt_init] startup took %f seconds", dt_get_wtime() - start_wtime);
+
+  dt_print_mem_usage("after successful startup");
+
   return 0;
 }
 
@@ -2482,7 +2481,7 @@ void dt_capabilities_cleanup()
 }
 
 
-void dt_print_mem_usage()
+void dt_print_mem_usage(char *info)
 {
   if(!(darktable.unmuted & DT_DEBUG_MEMORY))
     return;
@@ -2517,29 +2516,31 @@ void dt_print_mem_usage()
   fclose(f);
 
   dt_print(DT_DEBUG_ALWAYS,
-                  "[memory] max address space (vmpeak): %15s"
-                  "            [memory] cur address space (vmsize): %15s"
-                  "            [memory] max used memory   (vmhwm ): %15s"
-                  "            [memory] cur used memory   (vmrss ): %15s",
-          vmpeak, vmsize, vmhwm, vmrss);
+                  "[memory] %s\n"
+                  "             max address space (vmpeak): %15s"
+                  "             cur address space (vmsize): %15s"
+                  "             max used memory   (vmhwm ): %15s"
+                  "             cur used memory   (vmrss ): %15s",
+          info, vmpeak, vmsize, vmhwm, vmrss);
 
 #elif defined(__APPLE__)
   struct task_basic_info t_info;
   mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
 
   if(KERN_SUCCESS != task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count))
   {
-    dt_print(DT_DEBUG_ALWAYS, "[memory] task memory info unknown.");
+    dt_print(DT_DEBUG_ALWAYS, "[memory] task memory info unknown");
     return;
   }
 
   // Report in kB, to match output of /proc on Linux.
   dt_print(DT_DEBUG_ALWAYS,
-                  "[memory] max address space (vmpeak): %15s\n"
-                  "            [memory] cur address space (vmsize): %12llu kB\n"
-                  "            [memory] max used memory   (vmhwm ): %15s\n"
-                  "            [memory] cur used memory   (vmrss ): %12llu kB",
-          "unknown", (uint64_t)t_info.virtual_size / 1024, "unknown", (uint64_t)t_info.resident_size / 1024);
+                  "[memory] %s\n"
+                  "            max address space (vmpeak): %15s\n"
+                  "            cur address space (vmsize): %12llu kB\n"
+                  "            max used memory   (vmhwm ): %15s\n"
+                  "            cur used memory   (vmrss ): %12llu kB",
+          info, "unknown", (uint64_t)t_info.virtual_size / 1024, "unknown", (uint64_t)t_info.resident_size / 1024);
 #elif defined (_WIN32)
   //Based on: http://stackoverflow.com/questions/63166/how-to-determine-cpu-and-memory-consumption-from-inside-a-process
   MEMORYSTATUSEX memInfo;
@@ -2561,11 +2562,12 @@ void dt_print_mem_usage()
 
 
   dt_print(DT_DEBUG_ALWAYS,
-                  "[memory] max address space (vmpeak): %12llu kB\n"
-                  "            [memory] cur address space (vmsize): %12llu kB\n"
-                  "            [memory] max used memory   (vmhwm ): %12llu kB\n"
-                  "            [memory] cur used memory   (vmrss ): %12llu Kb",
-          virtualMemUsedByMeMax / 1024, virtualMemUsedByMe / 1024, physMemUsedByMeMax / 1024,
+                  "[memory] %s\n"
+                  "            max address space (vmpeak): %12llu kB\n"
+                  "            cur address space (vmsize): %12llu kB\n"
+                  "            max used memory   (vmhwm ): %12llu kB\n"
+                  "            cur used memory   (vmrss ): %12llu Kb",
+          info, virtualMemUsedByMeMax / 1024, virtualMemUsedByMe / 1024, physMemUsedByMeMax / 1024,
           physMemUsedByMe / 1024);
 
 #else

src/common/darktable.h

@@ -884,7 +884,7 @@ static inline gboolean dt_slist_length_equal(GSList *l1, GSList *l2)
 }
 
 // checks internally for DT_DEBUG_MEMORY
-void dt_print_mem_usage();
+void dt_print_mem_usage(char *info);
 
 // try to start the backthumbs crawler
 void dt_start_backtumbs_crawler();

src/develop/pixelpipe_cache.c

@@ -459,7 +459,7 @@ void dt_dev_pixelpipe_cache_checkmem(dt_dev_pixelpipe_t *pipe)
   }
 
   _cline_stats(cache);
-  dt_print_pipe(DT_DEBUG_PIPE, "pipe cache check", pipe, NULL, DT_DEVICE_NONE, NULL, NULL,
+  dt_print_pipe(DT_DEBUG_PIPE | DT_DEBUG_MEMORY, "pipe cache check", pipe, NULL, DT_DEVICE_NONE, NULL, NULL,
     "%i lines (important=%i, used=%i). Freed %iMB. Using using %iMB, limit=%iMB",
     cache->entries, cache->limportant, cache->lused,
     _to_mb(freed), _to_mb(cache->allmem), _to_mb(cache->memlimit));
@@ -470,7 +470,7 @@ void dt_dev_pixelpipe_cache_report(dt_dev_pixelpipe_t *pipe)
   dt_dev_pixelpipe_cache_t *cache = &(pipe->cache);
 
   _cline_stats(cache);
-  dt_print_pipe(DT_DEBUG_PIPE, "cache report", pipe, NULL, DT_DEVICE_NONE, NULL, NULL,
+  dt_print_pipe(DT_DEBUG_PIPE | DT_DEBUG_MEMORY, "cache report", pipe, NULL, DT_DEVICE_NONE, NULL, NULL,
     "%i lines (important=%i, used=%i, invalid=%i). Using %iMB, limit=%iMB. Hits/run=%.2f. Hits/test=%.3f",
     cache->entries, cache->limportant, cache->lused, cache->linvalid,
     _to_mb(cache->allmem), _to_mb(cache->memlimit),

src/develop/pixelpipe_hb.c

@@ -256,12 +256,17 @@ gboolean dt_dev_pixelpipe_init_cached(dt_dev_pixelpipe_t *pipe,
   return dt_dev_pixelpipe_cache_init(pipe, entries, size, memlimit);
 }
 
-static void get_output_format(
-              dt_iop_module_t *module,
-              dt_dev_pixelpipe_t *pipe,
-              dt_dev_pixelpipe_iop_t *piece,
-              dt_develop_t *dev,
-              dt_iop_buffer_dsc_t *dsc)
+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));
+}
+
+static void get_output_format(dt_iop_module_t *module,
+                              dt_dev_pixelpipe_t *pipe,
+                              dt_dev_pixelpipe_iop_t *piece,
+                              dt_develop_t *dev,
+                              dt_iop_buffer_dsc_t *dsc)
 {
   if(module) return module->output_format(module, pipe, piece, dsc);
 
@@ -662,15 +667,14 @@ void dt_dev_pixelpipe_usedetails(dt_dev_pixelpipe_t *pipe)
   pipe->want_detail_mask = TRUE;
 }
 
-static void _dump_pipe_pfm_diff(
-        const char *mod,
-        const void *indata,
-        const dt_iop_roi_t *roi_in,
-        const int inbpp,
-        const void *outdata,
-        const dt_iop_roi_t *roi_out,
-        const int outbpp,
-        const char *pipe)
+static void _dump_pipe_pfm_diff(const char *mod,
+                                const void *indata,
+                                const dt_iop_roi_t *roi_in,
+                                const int inbpp,
+                                const void *outdata,
+                                const dt_iop_roi_t *roi_out,
+                                const int outbpp,
+                                const char *pipe)
 {
   if(!darktable.dump_pfm_pipe) return;
   if(!mod) return;
@@ -1089,19 +1093,18 @@ static void _collect_histogram_on_CPU(dt_dev_pixelpipe_t *pipe,
   }
 }
 
-static gboolean _pixelpipe_process_on_CPU(
-                 dt_dev_pixelpipe_t *pipe,
-                 dt_develop_t *dev,
-                 float *input,
-                 dt_iop_buffer_dsc_t *input_format,
-                 const dt_iop_roi_t *roi_in,
-                 void **output,
-                 dt_iop_buffer_dsc_t **out_format,
-                 const dt_iop_roi_t *roi_out,
-                 dt_iop_module_t *module,
-                 dt_dev_pixelpipe_iop_t *piece,
-                 dt_develop_tiling_t *tiling,
-                 dt_pixelpipe_flow_t *pixelpipe_flow)
+static gboolean _pixelpipe_process_on_CPU(dt_dev_pixelpipe_t *pipe,
+                                          dt_develop_t *dev,
+                                          float *input,
+                                          dt_iop_buffer_dsc_t *input_format,
+                                          const dt_iop_roi_t *roi_in,
+                                          void **output,
+                                          dt_iop_buffer_dsc_t **out_format,
+                                          const dt_iop_roi_t *roi_out,
+                                          dt_iop_module_t *module,
+                                          dt_dev_pixelpipe_iop_t *piece,
+                                          dt_develop_tiling_t *tiling,
+                                          dt_pixelpipe_flow_t *pixelpipe_flow)
 {
   if(dt_atomic_get_int(&pipe->shutdown))
     return TRUE;
@@ -1162,7 +1165,7 @@ static gboolean _pixelpipe_process_on_CPU(
   const size_t m_width = MAX(roi_in->width, roi_out->width);
   const size_t m_height = MAX(roi_in->height, roi_out->height);
 
-  const gboolean fitting = dt_tiling_piece_fits_host_memory(m_width, m_height, m_bpp, tiling->factor, tiling->overhead);
+  const gboolean fitting = dt_tiling_piece_fits_host_memory(piece, m_width, m_height, m_bpp, tiling->factor, tiling->overhead);
   /* process module on cpu. use tiling if needed and possible. */
 
   const gboolean pfm_dump = darktable.dump_pfm_pipe
@@ -1330,16 +1333,15 @@ static inline gboolean _skip_piece_on_tags(const dt_dev_pixelpipe_iop_t *piece)
 }
 
 // recursive helper for process, returns TRUE in case of unfinished work or error
-static gboolean _dev_pixelpipe_process_rec(
-                 dt_dev_pixelpipe_t *pipe,
-                 dt_develop_t *dev,
-                 void **output,
-                 void **cl_mem_output,
-                 dt_iop_buffer_dsc_t **out_format,
-                 const dt_iop_roi_t *roi_out,
-                 GList *modules,
-                 GList *pieces,
-                 const int pos)
+static gboolean _dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe,
+                                           dt_develop_t *dev,
+                                           void **output,
+                                           void **cl_mem_output,
+                                           dt_iop_buffer_dsc_t **out_format,
+                                           const dt_iop_roi_t *roi_out,
+                                           GList *modules,
+                                           GList *pieces,
+                                           const int pos)
 {
   if(dt_atomic_get_int(&pipe->shutdown))
     return TRUE;
@@ -1917,13 +1919,13 @@ static gboolean _dev_pixelpipe_process_rec(
                   && (cho == 1 || cho == 4)
                   && dt_str_commasubstring(darktable.dump_diff_pipe, module->op))
               {
-                const size_t ow = roi_out->width;
-                const size_t oh = roi_out->height;
-                const size_t iw = roi_in.width;
-                const size_t ih = roi_in.height;
-                float *clindata = dt_alloc_align_float(iw * ih * ch);
-                float *cloutdata = dt_alloc_align_float(ow * oh * cho);
-                float *cpudata = dt_alloc_align_float(ow * oh * cho);
+                const int ow = roi_out->width;
+                const int oh = roi_out->height;
+                const int iw = roi_in.width;
+                const int ih = roi_in.height;
+                float *clindata = dt_alloc_align_float((size_t)iw * ih * ch);
+                float *cloutdata = dt_alloc_align_float((size_t)ow * oh * cho);
+                float *cpudata = dt_alloc_align_float((size_t)ow * oh * cho);
                 if(clindata && cloutdata && cpudata)
                 {
                   cl_int terr = dt_opencl_read_host_from_device(pipe->devid, cloutdata, *cl_mem_output, ow, oh, cho * sizeof(float));
@@ -2582,14 +2584,13 @@ static gboolean _dev_pixelpipe_process_rec(
 }
 
 
-gboolean dt_dev_pixelpipe_process_no_gamma(
-           dt_dev_pixelpipe_t *pipe,
-           dt_develop_t *dev,
-           const int x,
-           const int y,
-           const int width,
-           const int height,
-           const float scale)
+gboolean dt_dev_pixelpipe_process_no_gamma(dt_dev_pixelpipe_t *pipe,
+                                           dt_develop_t *dev,
+                                           const int x,
+                                           const int y,
+                                           const int width,
+                                           const int height,
+                                           const float scale)
 {
   // temporarily disable gamma mapping.
   GList *gammap = g_list_last(pipe->nodes);
@@ -2638,16 +2639,15 @@ void dt_dev_pixelpipe_disable_before(dt_dev_pixelpipe_t *pipe, const char *op)
 }
 
 // returns TRUE in case of error or early exit
-static gboolean _dev_pixelpipe_process_rec_and_backcopy(
-                  dt_dev_pixelpipe_t *pipe,
-                  dt_develop_t *dev,
-                  void **output,
-                  void **cl_mem_output,
-                  dt_iop_buffer_dsc_t **out_format,
-                  const dt_iop_roi_t *roi_out,
-                  GList *modules,
-                  GList *pieces,
-                  const int pos)
+static gboolean _dev_pixelpipe_process_rec_and_backcopy(dt_dev_pixelpipe_t *pipe,
+                                                        dt_develop_t *dev,
+                                                        void **output,
+                                                        void **cl_mem_output,
+                                                        dt_iop_buffer_dsc_t **out_format,
+                                                        const dt_iop_roi_t *roi_out,
+                                                        GList *modules,
+                                                        GList *pieces,
+                                                        const int pos)
 {
   dt_pthread_mutex_lock(&pipe->busy_mutex);
   darktable.dtresources.group = 4 * darktable.dtresources.level;
@@ -2691,15 +2691,14 @@ static gboolean _dev_pixelpipe_process_rec_and_backcopy(
   return ret;
 }
 
-gboolean dt_dev_pixelpipe_process(
-           dt_dev_pixelpipe_t *pipe,
-           dt_develop_t *dev,
-           const int x,
-           const int y,
-           const int width,
-           const int height,
-           const float scale,
-           const int devid)
+gboolean dt_dev_pixelpipe_process(dt_dev_pixelpipe_t *pipe,
+                                  dt_develop_t *dev,
+                                  const int x,
+                                  const int y,
+                                  const int width,
+                                  const int height,
+                                  const float scale,
+                                  const int devid)
 {
   pipe->processing = TRUE;
   pipe->nocache = (pipe->type & DT_DEV_PIXELPIPE_IMAGE) != 0;
@@ -2713,9 +2712,6 @@ gboolean dt_dev_pixelpipe_process(
   if(!claimed)  // don't free cachelines as the caller is using them
     dt_dev_pixelpipe_cache_checkmem(pipe);
 
-  dt_print(DT_DEBUG_MEMORY, "[memory] before pixelpipe process");
-  dt_print_mem_usage();
-
   if(pipe->devid > DT_DEVICE_CPU) dt_opencl_events_reset(pipe->devid);
 
   dt_iop_roi_t roi = (dt_iop_roi_t){ x, y, width, height, scale };
@@ -2758,9 +2754,13 @@ gboolean dt_dev_pixelpipe_process(
       pipe->image.id,
       darktable.opencl->dev[pipe->devid].cname);
   else
-#endif
     dt_print_pipe(DT_DEBUG_PIPE, "pipe starting", pipe, NULL, pipe->devid, &roi, &roi, "ID=%i",
       pipe->image.id);
+#else
+  dt_print_pipe(DT_DEBUG_PIPE, "pipe starting", pipe, NULL, pipe->devid, &roi, &roi, "ID=%i",
+      pipe->image.id);
+#endif
+  dt_print_mem_usage("before pixelpipe process");
 
   // run pixelpipe recursively and get error status
   const gboolean err = _dev_pixelpipe_process_rec_and_backcopy(pipe, dev, &buf,
@@ -2772,10 +2772,9 @@ gboolean dt_dev_pixelpipe_process(
                           ? (dt_opencl_events_flush(pipe->devid, TRUE) != 0)
                           : FALSE;
 
-  // Check if we had opencl errors,
-  // remark: opencl errors can come in two ways:
-  // processed pipe->opencl_error checked via 'err'
-  // OpenCL events so oclerr is TRUE
+  // Check if we had opencl errors, those can come in two ways:
+  //   processed pipe->opencl_error checked via 'err'
+  //   OpenCL events so oclerr is TRUE
   const int old_devid = pipe->devid;
   if(oclerr || (err && pipe->opencl_error))
   {
@@ -2874,8 +2873,9 @@ gboolean dt_dev_pixelpipe_process(
   if(!claimed)
     dt_dev_pixelpipe_cache_report(pipe);
 
-  dt_print_pipe(DT_DEBUG_PIPE, "pipe finished", pipe, NULL, old_devid, &roi, &roi, "ID=%i\n",
+  dt_print_pipe(DT_DEBUG_PIPE, "pipe finished", pipe, NULL, old_devid, &roi, &roi, "ID=%i",
     pipe->image.id);
+  dt_print_mem_usage("after pixelpipe process");
 
   pipe->processing = FALSE;
   return FALSE;

src/develop/pixelpipe_hb.h

@@ -231,6 +231,8 @@ gboolean dt_dev_pixelpipe_init_cached(dt_dev_pixelpipe_t *pipe,
                                       const size_t size,
                                       const int32_t entries,
                                       const size_t memlimit);
+// returns available memory for the pipe
+size_t dt_get_available_pipe_mem(const dt_dev_pixelpipe_t *pipe);
 // constructs a new input buffer from given RGB float array.
 void dt_dev_pixelpipe_set_input(dt_dev_pixelpipe_t *pipe,
                                 struct dt_develop_t *dev,