[gegl] buffer: improve swap tile compression while stalling

[Ell <ell src gnome org>]

commit 8b48235c34e92ff6d6fcf6e83f82325c977cb827
Author: Ell <ell_se yahoo com>
Date:   Mon Dec 31 02:27:42 2018 -0500

    buffer: improve swap tile compression while stalling

 gegl/buffer/gegl-tile-backend-swap.c | 138 ++++++++++++++++++-----------------
 1 file changed, 72 insertions(+), 66 deletions(-)
---
diff --git a/gegl/buffer/gegl-tile-backend-swap.c b/gegl/buffer/gegl-tile-backend-swap.c
index 62cf3c97e..90da610a0 100644
--- a/gegl/buffer/gegl-tile-backend-swap.c
+++ b/gegl/buffer/gegl-tile-backend-swap.c
@@ -260,95 +260,101 @@ gegl_tile_backend_swap_push_queue (ThreadParams *params,
         {
           queue_stalls++;
 
-          while (params                        &&
-                 params->operation == OP_WRITE &&
-                 queued_cost > queued_max)
+          while (queued_cost > queued_max)
             {
-              if (params->tile               &&
-                  params->block->compression &&
-                  ! params->compressing)
+              params = g_queue_peek_tail (queue);
+
+              while (params                        &&
+                     params->operation == OP_WRITE &&
+                     queued_cost > queued_max)
                 {
-                  SwapBlock             *block;
-                  GeglTile              *tile;
-                  const GeglCompression *compression;
-                  const Babl            *format;
-                  gint                   tile_size;
-                  gint                   bpp;
-                  gpointer               compressed;
-                  gint                   max_compressed_size;
-                  gint                   compressed_size;
-                  gboolean               success;
+                  if (params->tile               &&
+                      params->block->compression &&
+                      ! params->compressing)
+                    {
+                      SwapBlock             *block;
+                      GeglTile              *tile;
+                      const GeglCompression *compression;
+                      const Babl            *format;
+                      gint                   tile_size;
+                      gint                   bpp;
+                      gpointer               compressed;
+                      gint                   max_compressed_size;
+                      gint                   compressed_size;
+                      gboolean               success;
 
-                  block       = params->block;
-                  tile        = gegl_tile_ref (params->tile);
-                  compression = block->compression;
-                  format      = params->format;
-                  tile_size   = params->size;
+                      block       = params->block;
+                      tile        = gegl_tile_ref (params->tile);
+                      compression = block->compression;
+                      format      = params->format;
+                      tile_size   = params->size;
 
-                  gegl_tile_backend_swap_block_ref (block, tile_size);
+                      gegl_tile_backend_swap_block_ref (block, tile_size);
 
-                  params->compressing = TRUE;
+                      params->compressing = TRUE;
 
-                  g_mutex_unlock (&queue_mutex);
+                      g_mutex_unlock (&queue_mutex);
 
-                  bpp = babl_format_get_bytes_per_pixel (format);
+                      bpp = babl_format_get_bytes_per_pixel (format);
 
-                  max_compressed_size = tile_size * COMPRESSION_MAX_RATIO;
-                  compressed          = g_malloc (max_compressed_size);
+                      max_compressed_size = tile_size * COMPRESSION_MAX_RATIO;
+                      compressed          = g_malloc (max_compressed_size);
 
-                  success = gegl_compression_compress (
-                    compression, format,
-                    gegl_tile_get_data (tile), tile_size / bpp,
-                    compressed, &compressed_size, max_compressed_size);
+                      success = gegl_compression_compress (
+                        compression, format,
+                        gegl_tile_get_data (tile), tile_size / bpp,
+                        compressed, &compressed_size, max_compressed_size);
 
-                  g_mutex_lock (&queue_mutex);
+                      g_mutex_lock (&queue_mutex);
 
-                  params = NULL;
+                      params = NULL;
 
-                  if (block->link)
-                    {
-                      params = block->link->data;
+                      if (block->link)
+                        {
+                          params = block->link->data;
 
-                      if (params->tile != tile)
-                        params = NULL;
-                    }
+                          if (params->tile != tile)
+                            params = NULL;
+                        }
 
-                  if (success && params)
-                    {
-                      gegl_tile_backend_swap_free_data (params);
+                      if (success && params)
+                        {
+                          gegl_tile_backend_swap_free_data (params);
 
-                      params->compressed      = compressed;
-                      params->compressed_size = compressed_size;
+                          params->compressed      = compressed;
+                          params->compressed_size = compressed_size;
 
-                      queued_total += params->compressed_size;
-                      queued_cost  += params->compressed_size;
-                    }
-                  else
-                    {
-                      if (params)
-                        params->block->compression = NULL;
+                          queued_total += params->compressed_size;
+                          queued_cost  += params->compressed_size;
+                        }
+                      else
+                        {
+                          if (params)
+                            params->block->compression = NULL;
 
-                      g_free (compressed);
-                    }
+                          g_free (compressed);
+                        }
 
-                  gegl_tile_backend_swap_block_unref (block, tile_size, FALSE);
+                      gegl_tile_backend_swap_block_unref (block,
+                                                          tile_size, FALSE);
 
-                  gegl_tile_unref (tile);
-                }
+                      gegl_tile_unref (tile);
+                    }
 
-              if (params)
-                {
-                  GList *link = g_list_previous (params->block->link);
+                  if (params)
+                    {
+                      GList *link = g_list_previous (params->block->link);
 
-                  if (link)
-                    params = link->data;
-                  else
-                    params = NULL;
+                      if (link)
+                        params = link->data;
+                      else
+                        params = NULL;
+                    }
                 }
-            }
 
-          while (queued_cost > queued_max)
-            g_cond_wait (&push_cond, &queue_mutex);
+              if (queued_cost > queued_max)
+                g_cond_wait (&push_cond, &queue_mutex);
+            }
         }
     }
 }