test_pipe_cache_policy.c

Go to the documentation of this file.

/*
    This file is part of Ansel,
    Copyright (C) 2026 Aurélien PIERRE.
 
    Ansel is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Ansel is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "develop/pipe_cache_policy.h"
 
#include <stdarg.h>
#include <stddef.h>
// cmocka.h declares `extern jmp_buf global_expect_assert_env' at file scope without including
// <setjmp.h> itself. Same suppression as test_metadata_notify.c, and for the same reason.
#include <setjmp.h>  // NOLINT(misc-include-cleaner)
#include <stdint.h>
#include <cmocka.h>
 
static dt_dev_pipe_cache_policy_inputs_t _gpu_node_with_no_needs(void)
{
  dt_dev_pipe_cache_policy_inputs_t in = { 0 };
  in.supports_opencl = TRUE;
  return in;
}
 
static void _cpu_only_node_needs_its_input_on_host(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t in = { 0 };
  in.supports_opencl = FALSE;
 
  gboolean upstream = FALSE;
  const gboolean own = dt_dev_pipe_cache_policy_decide(&in, FALSE, &upstream);
 
  // It requires nothing of its OWN output -- nobody downstream asked for it ...
  assert_false(own);
  // ... but the node before it must publish to host, because this one reads on the CPU.
  assert_true(upstream);
}
 
static void _gpu_node_requires_nothing_on_its_own(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t in = _gpu_node_with_no_needs();
 
  gboolean upstream = TRUE;
  const gboolean own = dt_dev_pipe_cache_policy_decide(&in, FALSE, &upstream);
 
  assert_false(own);
  assert_false(upstream);
}
 
static void _a_gpu_node_does_not_relay_its_consumers_requirement(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t in = _gpu_node_with_no_needs();
 
  gboolean upstream = TRUE;
  const gboolean own = dt_dev_pipe_cache_policy_decide(&in, TRUE, &upstream);
 
  // The consumer's requirement still reaches THIS node's output: that consumer reads it.
  assert_true(own);
  // ... and stops there. The node before this one publishes to this node, which is on GPU.
  assert_false(upstream);
}
 
static void _a_cpu_node_still_makes_its_producer_publish(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t in = { 0 }; // supports_opencl = FALSE
 
  gboolean upstream = FALSE;
  dt_dev_pipe_cache_policy_decide(&in, FALSE, &upstream);
  assert_true(upstream);
}
 
static void _a_gpu_node_nothing_reads_from_ram_caches_nothing(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t in = _gpu_node_with_no_needs();
 
  gboolean upstream = TRUE;
  assert_false(dt_dev_pipe_cache_policy_decide(&in, FALSE, &upstream));
  assert_false(upstream);
}
 
static void _each_own_input_reason_raises_upstream(void **state)
{
  (void)state;
  const size_t offsets[] = {
    offsetof(dt_dev_pipe_cache_policy_inputs_t, active_in_gui),
    offsetof(dt_dev_pipe_cache_policy_inputs_t, module_hist_on),
    offsetof(dt_dev_pipe_cache_policy_inputs_t, global_hist_input_on),
    offsetof(dt_dev_pipe_cache_policy_inputs_t, has_autoset),
  };
 
  for(size_t i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++)
  {
    dt_dev_pipe_cache_policy_inputs_t in = _gpu_node_with_no_needs();
    *(gboolean *)((char *)&in + offsets[i]) = TRUE;
 
    gboolean upstream = FALSE;
    dt_dev_pipe_cache_policy_decide(&in, FALSE, &upstream);
    assert_true(upstream);
  }
}
 
static void _each_own_output_reason_raises_own(void **state)
{
  (void)state;
  const size_t offsets[] = {
    offsetof(dt_dev_pipe_cache_policy_inputs_t, authored_cache),
    offsetof(dt_dev_pipe_cache_policy_inputs_t, user_requested_cache),
    offsetof(dt_dev_pipe_cache_policy_inputs_t, color_picker_on),
    offsetof(dt_dev_pipe_cache_policy_inputs_t, global_hist_output_on),
  };
 
  for(size_t i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++)
  {
    dt_dev_pipe_cache_policy_inputs_t in = _gpu_node_with_no_needs();
    *(gboolean *)((char *)&in + offsets[i]) = TRUE;
 
    gboolean upstream = FALSE;
    assert_true(dt_dev_pipe_cache_policy_decide(&in, FALSE, &upstream));
    // None of these four says anything about what the node BEFORE this one must do.
    assert_false(upstream);
  }
}
 
static void _null_upstream_pointer_is_allowed(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t in = _gpu_node_with_no_needs();
  in.color_picker_on = TRUE;
 
  assert_true(dt_dev_pipe_cache_policy_decide(&in, FALSE, NULL));
}
 
static void _walk(const dt_dev_pipe_cache_policy_inputs_t *nodes, gboolean *out, const int count,
                  const gboolean display_reads_the_last_output)
{
  gboolean carried = display_reads_the_last_output;
  for(int i = count - 1; i >= 0; i--)
    out[i] = dt_dev_pipe_cache_policy_decide(&nodes[i], carried, &carried);
}
 
static void _only_the_displayed_output_is_cached_in_a_gpu_chain(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t nodes[4];
  for(int i = 0; i < 4; i++) nodes[i] = _gpu_node_with_no_needs();
 
  gboolean cached[4] = { FALSE };
  _walk(nodes, cached, 4, TRUE);
 
  assert_true(cached[3]);   // the displayed output
  assert_false(cached[2]);  // ... and nothing else. Relayed, these were all TRUE.
  assert_false(cached[1]);
  assert_false(cached[0]);
}
 
static void _a_cpu_node_publishes_its_producer_and_no_further(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t nodes[4];
  for(int i = 0; i < 4; i++) nodes[i] = _gpu_node_with_no_needs();
  nodes[2].supports_opencl = FALSE;   // CPU-only: reads its input from RAM
 
  gboolean cached[4] = { FALSE };
  _walk(nodes, cached, 4, TRUE);
 
  assert_true(cached[3]);   // displayed
  /* The CPU node's OWN flag is FALSE, and that is correct rather than an oversight: the flag
   * asks for a device->host COPY of a module's output, and a module that ran on the CPU has
   * already written its output in host memory. There is nothing to copy. (Asserting TRUE here
   * is what this test caught on its first run.) */
  assert_false(cached[2]);
  assert_true(cached[1]);   // its PRODUCER must publish -- this is the one that matters
  assert_false(cached[0]);  // and the requirement stops there
}
 
static void _a_pure_gpu_chain_nobody_reads_caches_nothing(void **state)
{
  (void)state;
  dt_dev_pipe_cache_policy_inputs_t nodes[3];
  for(int i = 0; i < 3; i++) nodes[i] = _gpu_node_with_no_needs();
 
  gboolean cached[3] = { FALSE };
  _walk(nodes, cached, 3, FALSE);
 
  for(int i = 0; i < 3; i++) assert_false(cached[i]);
}
 
int main(void)
{
  const struct CMUnitTest tests[] = {
    cmocka_unit_test(_cpu_only_node_needs_its_input_on_host),
    cmocka_unit_test(_gpu_node_requires_nothing_on_its_own),
    cmocka_unit_test(_a_gpu_node_does_not_relay_its_consumers_requirement),
    cmocka_unit_test(_a_cpu_node_still_makes_its_producer_publish),
    cmocka_unit_test(_a_gpu_node_nothing_reads_from_ram_caches_nothing),
    cmocka_unit_test(_each_own_input_reason_raises_upstream),
    cmocka_unit_test(_each_own_output_reason_raises_own),
    cmocka_unit_test(_null_upstream_pointer_is_allowed),
    cmocka_unit_test(_only_the_displayed_output_is_cached_in_a_gpu_chain),
    cmocka_unit_test(_a_cpu_node_publishes_its_producer_and_no_further),
    cmocka_unit_test(_a_pure_gpu_chain_nobody_reads_caches_nothing),
  };
 
  return cmocka_run_group_tests(tests, NULL, NULL);
}
 
// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on