LRU: add test for eviction and re-decompression

Author: Grok Compression

src/lib/core/codestream/decompress/CodeStreamDecompress.cpp

@@ -136,6 +136,7 @@ void CodeStreamDecompress::init(grk_decompress_parameters* parameters)
   cp_.init(parameters, tileCache_);
   auto core = &parameters->core;
   tileCache_->setStrategy(core->tile_cache_strategy);
+  tileCache_->setMaxActiveTiles(core->max_active_tiles);
   ioBufferCallback_ = core->io_buffer_callback;
   ioUserData_ = core->io_user_data;
   grkRegisterReclaimCallback_ = core->io_register_client_callback;
@@ -257,25 +258,34 @@ bool CodeStreamDecompress::decompressImpl(std::set<uint16_t> pendingTiles)
   if(pendingTiles.empty())
     return true;
 
-  // Extract LRU-evicted tiles that can be re-decompressed from cache
-  // (opt-in: only when compressed chunk cache is active and TLM is present)
-  std::set<uint16_t> reDecompressTiles;
-  if(compressedChunkCache_ && cp_.hasTLM())
+  // Extract LRU-evicted tiles that can be re-decompressed
+  std::set<uint16_t> reDecompressTLM; // from compressed chunk cache
+  std::set<uint16_t> reDecompressSeek; // from cached SOT offsets
+  for(auto it = pendingTiles.begin(); it != pendingTiles.end();)
   {
-    for(auto it = pendingTiles.begin(); it != pendingTiles.end();)
+    auto cacheEntry = tileCache_->get(*it);
+    if(cacheEntry && cacheEntry->processor->getImage() && !cacheEntry->processor->getTile() &&
+       cacheEntry->dirty_)
     {
-      auto cacheEntry = tileCache_->get(*it);
-      if(cacheEntry && cacheEntry->processor->getImage() && !cacheEntry->processor->getTile() &&
-         cacheEntry->dirty_ && compressedChunkCache_->contains(*it))
+      if(compressedChunkCache_ && compressedChunkCache_->contains(*it))
       {
-        reDecompressTiles.insert(*it);
+        reDecompressTLM.insert(*it);
+        it = pendingTiles.erase(it);
+      }
+      else if(cacheEntry->processor->allSOTMarkersParsed())
+      {
+        reDecompressSeek.insert(*it);
         it = pendingTiles.erase(it);
       }
       else
       {
         ++it;
       }
     }
+    else
+    {
+      ++it;
+    }
   }
 
   // Require tile_ to exist for differential updates — an LRU-evicted tile
@@ -299,7 +309,7 @@ bool CodeStreamDecompress::decompressImpl(std::set<uint16_t> pendingTiles)
   numTilesDecompressed_ = 0;
 
   // Re-decompress LRU-evicted tiles from compressed chunk cache
-  for(auto tileIndex : reDecompressTiles)
+  for(auto tileIndex : reDecompressTLM)
   {
     auto cacheEntry = tileCache_->get(tileIndex);
     auto proc = cacheEntry->processor;
@@ -313,6 +323,20 @@ bool CodeStreamDecompress::decompressImpl(std::set<uint16_t> pendingTiles)
     cacheEntry->dirty_ = false;
   }
 
+  // Re-decompress LRU-evicted tiles by seeking to cached SOT offsets
+  for(auto tileIndex : reDecompressSeek)
+  {
+    auto cacheEntry = tileCache_->get(tileIndex);
+    auto proc = cacheEntry->processor;
+    if(!proc->reinitForReDecompress())
+      continue;
+    if(!proc->decompressFromCachedTileParts())
+      continue;
+    if(!schedule(proc, true))
+      break;
+    cacheEntry->dirty_ = false;
+  }
+
   if(pendingTiles.empty())
     return true;
 
@@ -1233,7 +1257,20 @@ void CodeStreamDecompress::wait(grk_wait_swath* swath)
     return;
   }
 
-  // 2. wait for sequential parse
+  // 2a. Flush batch queues when using non-swath full wait.
+  // When tileCompletion_ is active but wait(nullptr) is called (not swath-based),
+  // the back-pressure logic in scheduleTileBatch() prevents scheduling queued tiles
+  // because lastCleared never advances (no swath consumer). Force-schedule all
+  // remaining tiles so the worker thread can exit.
+  if(tileCompletion_ && doTileBatching())
+  {
+    // Remove the scheduling limit so scheduleTileBatch can drain
+    batchTileScheduledRows_ = 0;
+    tileCompletion_->setLastClearedTileY(INT16_MAX);
+    scheduleTileBatch();
+  }
+
+  // 2b. wait for sequential parse
   if(decompressWorker_.joinable())
     decompressWorker_.join();
 

src/lib/core/grok.h

@@ -674,6 +674,8 @@ typedef struct _grk_decompress_core_params
    */
   uint16_t layers_to_decompress;
   uint32_t tile_cache_strategy; /* tile cache strategy */
+  uint16_t
+      max_active_tiles; /* max tiles with decompressed data (LRU eviction limit, 0 = unlimited) */
   uint32_t disable_random_access_flags; /* disable random access flags */
   bool skip_allocate_composite; /* skip allocate composite image data for multi-tile */
   grk_io_pixels_callback io_buffer_callback; /* IO buffer callback */

src/lib/core/tile_processor/TileCompletion.h

@@ -325,6 +325,12 @@ class TileCompletion
     return lastClearedTileY_;
   }
 
+  void setLastClearedTileY(int32_t val)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    lastClearedTileY_ = val;
+  }
+
   int32_t getNeededTileY1() const
   {
     return neededTileY1_.load(std::memory_order_acquire);

tests/GrkLRUCacheTest.cpp

@@ -53,16 +53,17 @@ struct CodecDeleter
 };
 using CodecPtr = std::unique_ptr<grk_object, CodecDeleter>;
 
-// Create a synthetic test image and compress it to a J2K file with TLM markers
+// Create a synthetic test image and compress it to a J2K file
 static bool createTestImage(const std::string& path, uint32_t width, uint32_t height,
-                            uint32_t tileWidth, uint32_t tileHeight)
+                            uint32_t tileWidth, uint32_t tileHeight, bool writeTlm = true)
 {
   grk_cparameters cparams{};
   grk_compress_set_default_params(&cparams);
   cparams.cod_format = GRK_FMT_J2K;
   cparams.t_width = tileWidth;
   cparams.t_height = tileHeight;
-  cparams.write_tlm = true;
+  cparams.tile_size_on = (tileWidth < width || tileHeight < height);
+  cparams.write_tlm = writeTlm;
   cparams.numresolution = 3;
   // Lossless
   cparams.irreversible = false;
@@ -362,6 +363,150 @@ static bool testLRUCacheEviction()
   return true;
 }
 
+///////////////////////////////////////////////////////////////////
+// Test 4: LRU eviction + re-decompress from cached SOT offsets
+//
+// Creates a non-TLM image with 16 tiles, sets max_active_tiles=4,
+// decompresses all tiles (causing eviction), then re-decompresses
+// evicted tiles and verifies pixel data matches a fresh reference.
+///////////////////////////////////////////////////////////////////
+static std::vector<TileData> decompressTileByTile(const std::string& path,
+                                                  uint32_t tileCacheStrategy,
+                                                  uint16_t maxActiveTiles)
+{
+  std::vector<TileData> result;
+
+  grk_decompress_parameters params{};
+  params.core.tile_cache_strategy = tileCacheStrategy;
+  params.core.max_active_tiles = maxActiveTiles;
+
+  grk_stream_params streamParams{};
+  safe_strcpy(streamParams.file, path.data());
+
+  CodecPtr codec(grk_decompress_init(&streamParams, &params));
+  if(!codec)
+  {
+    spdlog::error("Failed to init decompressor");
+    return result;
+  }
+
+  grk_header_info headerInfo{};
+  if(!grk_decompress_read_header(codec.get(), &headerInfo))
+  {
+    spdlog::error("Failed to read header");
+    return result;
+  }
+
+  if(!grk_decompress_update(&params, codec.get()))
+  {
+    spdlog::error("grk_decompress_update failed");
+    return result;
+  }
+
+  uint16_t numTiles = headerInfo.t_grid_width * headerInfo.t_grid_height;
+  spdlog::info("decompressTileByTile: grid {}x{} = {} tiles", headerInfo.t_grid_width,
+               headerInfo.t_grid_height, numTiles);
+  for(uint16_t t = 0; t < numTiles; ++t)
+  {
+    if(!grk_decompress_tile(codec.get(), t))
+    {
+      spdlog::error("grk_decompress_tile({}) failed", t);
+      return {};
+    }
+  }
+
+  // Now re-decompress all tiles (evicted tiles trigger re-decompress path)
+  for(uint16_t t = 0; t < numTiles; ++t)
+  {
+    if(!grk_decompress_tile(codec.get(), t))
+    {
+      spdlog::error("Re-decompress of tile {} failed", t);
+      return {};
+    }
+
+    auto* tileImg = grk_decompress_get_tile_image(codec.get(), t, true);
+    if(!tileImg)
+    {
+      spdlog::error("get_tile_image({}) returned null after re-decompress", t);
+      return {};
+    }
+
+    TileData td;
+    td.tileIndex = t;
+    for(uint16_t c = 0; c < tileImg->numcomps; ++c)
+    {
+      auto& comp = tileImg->comps[c];
+      if(!comp.data)
+        continue;
+      uint32_t w = comp.w;
+      uint32_t h = comp.h;
+      auto* pixelData = static_cast<int32_t*>(comp.data);
+      std::vector<int32_t> pixels(pixelData, pixelData + w * h);
+      td.componentData.push_back(std::move(pixels));
+    }
+    result.push_back(std::move(td));
+  }
+
+  return result;
+}
+
+static bool testLRUEvictionReDecompress(const std::string& testFile)
+{
+  spdlog::info("=== Test: LRU eviction + re-decompress from cached SOT offsets ===");
+
+  // Reference: decompress each tile individually, no LRU
+  auto refData = decompressTileByTile(testFile, GRK_TILE_CACHE_IMAGE, 0);
+  if(refData.empty())
+  {
+    spdlog::error("Reference tile-by-tile decompression produced no data");
+    return false;
+  }
+  spdlog::info("Reference: {} tiles captured", refData.size());
+
+  // Test: decompress with LRU, max_active_tiles=4 (forces eviction on 16-tile image)
+  auto lruData = decompressTileByTile(testFile, GRK_TILE_CACHE_IMAGE | GRK_TILE_CACHE_LRU, 4);
+  if(lruData.empty())
+  {
+    spdlog::error("LRU re-decompress produced no data");
+    return false;
+  }
+  spdlog::info("LRU re-decompress: {} tiles captured", lruData.size());
+
+  if(refData.size() != lruData.size())
+  {
+    spdlog::error("Tile count mismatch: ref={}, lru={}", refData.size(), lruData.size());
+    return false;
+  }
+
+  for(size_t i = 0; i < refData.size(); ++i)
+  {
+    auto& ref = refData[i];
+    auto& lru = lruData[i];
+    if(ref.tileIndex != lru.tileIndex)
+    {
+      spdlog::error("Tile index mismatch at position {}", i);
+      return false;
+    }
+    if(ref.componentData.size() != lru.componentData.size())
+    {
+      spdlog::error("Component count mismatch for tile {}", ref.tileIndex);
+      return false;
+    }
+    for(size_t c = 0; c < ref.componentData.size(); ++c)
+    {
+      if(ref.componentData[c] != lru.componentData[c])
+      {
+        spdlog::error("Pixel data mismatch for tile {} component {}", ref.tileIndex, c);
+        return false;
+      }
+    }
+  }
+
+  spdlog::info("PASS: LRU eviction + re-decompress matches reference for all {} tiles",
+               refData.size());
+  return true;
+}
+
 ///////////////////////////////////////////////////////////////////
 // Main
 ///////////////////////////////////////////////////////////////////
@@ -395,6 +540,24 @@ int GrkLRUCacheTest::main(int argc, char** argv)
     std::filesystem::remove(testFile, ec);
   }
 
+  // Integration test: non-TLM image with LRU eviction + re-decompress
+  std::string noTlmFile =
+      (std::filesystem::temp_directory_path() / "grk_lru_no_tlm_test.j2k").string();
+  bool noTlmCreated = createTestImage(noTlmFile, 256, 256, 64, 64, false); // 4x4 = 16 tiles, no TLM
+  if(!noTlmCreated)
+  {
+    spdlog::error("Failed to create non-TLM test image, skipping eviction test");
+    failures++;
+  }
+  else
+  {
+    if(!testLRUEvictionReDecompress(noTlmFile))
+      failures++;
+
+    std::error_code ec;
+    std::filesystem::remove(noTlmFile, ec);
+  }
+
   if(failures > 0)
   {
     spdlog::error("{} test(s) FAILED", failures);