test_instrument.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <string.h>
 
#include "tests.h"
#include "instrument.h"
#include "instrument_internal.h"
 
static void utest_region_name(void);
static void utest_disabled_is_noop(void);
static void utest_single_region(void);
static void utest_nested_regions(void);
static void utest_deeply_nested_regions(void);
static void utest_sibling_nested_regions(void);
static void utest_reregister_destroys_old_handles(void);
static void utest_start_only_no_stop_cb(void);
 
int main(void) {
 
  utest_region_name();
  utest_disabled_is_noop();
  utest_single_region();
  utest_nested_regions();
  utest_deeply_nested_regions();
  utest_sibling_nested_regions();
  utest_reregister_destroys_old_handles();
  utest_start_only_no_stop_cb();
 
  return TEST_EXIT_CODE;
}
 
static int dummy_handle_storage[YAC_INSTR_REGION_COUNT];
 
typedef struct {
  int create_calls[YAC_INSTR_REGION_COUNT];
  int start_calls[YAC_INSTR_REGION_COUNT];
  int stop_calls[YAC_INSTR_REGION_COUNT];
  int destroy_calls[YAC_INSTR_REGION_COUNT];
  int last_start_depth[YAC_INSTR_REGION_COUNT];
  int last_stop_depth[YAC_INSTR_REGION_COUNT];
  void * last_start_handle[YAC_INSTR_REGION_COUNT];
  void * last_stop_handle[YAC_INSTR_REGION_COUNT];
  void * last_destroy_handle[YAC_INSTR_REGION_COUNT];
  int call_order[4 * YAC_INSTR_REGION_COUNT];
  int call_order_count;
} instr_counters;
 
static void utest_record_call(instr_counters * ctx, int tag) {
  if (ctx->call_order_count < (int)(sizeof(ctx->call_order) /
                                     sizeof(ctx->call_order[0])))
    ctx->call_order[ctx->call_order_count++] = tag;
}
 
// tags used to encode (callback kind, region id) pairs in call_order
enum { CREATE_TAG = 0, START_TAG = 100, STOP_TAG = 200, DESTROY_TAG = 300 };
 
static void * utest_create_cb(int id, void * user_data) {
 
  instr_counters * ctx = (instr_counters *)user_data;
  ctx->create_calls[id]++;
  utest_record_call(ctx, CREATE_TAG + id);
  return &dummy_handle_storage[id];
}
 
static void utest_start_cb(
  int id, void * handle, int depth, void * user_data) {
 
  instr_counters * ctx = (instr_counters *)user_data;
  ctx->start_calls[id]++;
  ctx->last_start_depth[id] = depth;
  ctx->last_start_handle[id] = handle;
  utest_record_call(ctx, START_TAG + id);
}
 
static void utest_stop_cb(
  int id, void * handle, int depth, void * user_data) {
 
  instr_counters * ctx = (instr_counters *)user_data;
  ctx->stop_calls[id]++;
  ctx->last_stop_depth[id] = depth;
  ctx->last_stop_handle[id] = handle;
  utest_record_call(ctx, STOP_TAG + id);
}
 
static void utest_destroy_cb(
  int id, void * handle, void * user_data) {
 
  instr_counters * ctx = (instr_counters *)user_data;
  ctx->destroy_calls[id]++;
  ctx->last_destroy_handle[id] = handle;
  utest_record_call(ctx, DESTROY_TAG + id);
}
 
static void utest_region_name(void) {
 
  // set reference names
  char const * ref_region_names[YAC_INSTR_REGION_COUNT] = {0};
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_NEW] =
    "distributed grid pair generation";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_DECOMP] =
    "distributed grid pair decomposition";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_REDIST] =
    "distributed grid pair redistribution";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_POINT_SEARCH] =
    "distributed grid pair point search";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_POINT_SEARCH_GC] =
    "distributed grid pair point search (great circle edges)";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_NNN_SEARCH] =
    "distributed grid pair n-nearest-neighbour search";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_BND_CIRCLE_SEARCH] =
    "distributed grid pair bounding circle search";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_DNN_SEARCH] =
    "distributed grid pair distance-nearest-neighbour search";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_CELL_SEARCH] =
    "distributed grid pair cell search";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_AUX_GRID] =
    "distributed grid pair auxiliary grid generation";
  ref_region_names[YAC_INSTR_DIST_GRID_PAIR_RELOCATE_POINTS] =
    "distributed grid pair point pair relocation";
  ref_region_names[YAC_INSTR_DIST_GRID_GLOBAL_TO_LOCAL] =
    "distributed grid global to local id conversion";
  ref_region_names[YAC_INSTR_GEN_PROC_SPHERE_PART] =
    "process sphere part generation";
  ref_region_names[YAC_INSTR_COMPUTE_TGT_FIELD] =
    "target field computation (SpMV)";
  ref_region_names[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] =
    "target field computation (direct copy)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH] =
    "interpolation search (method stack)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_AVG] =
    "interpolation search (average)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_NCC] =
    "interpolation search (nearest corner cells)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_NNN] =
    "interpolation search (n-nearest-neighbour)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_1NN] =
    "interpolation search (nearest-neighbour)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_ZERO] =
    "interpolation search (zero)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_DNN] =
    "interpolation search (distance-nearest-neighbour)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_CONSERV_1ST] =
    "interpolation search (1st order conservative)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_CONSERV_2ND] =
    "interpolation search (2nd order conservative)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_FIXED] =
    "interpolation search (fixed value)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_FILE] =
    "interpolation search (user file)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_CHECK] =
    "interpolation search (check)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_HCSBB] =
    "interpolation search (Bernstein Bezier)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_CREEP] =
    "interpolation search (creep)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_CALLBACK] =
    "interpolation search (user callback)";
  ref_region_names[YAC_INSTR_INTERP_SEARCH_SPMAP] =
    "interpolation search (source to target map)";
 
  for (size_t i = 0; i < YAC_INSTR_REGION_COUNT; i++) {
    char const *name = yac_instrument_region_name((yac_instrument_region_id)i);
    if (name == NULL)
      PUT_ERR_F("yac_instrument_region_name: unexpected NULL for region %zu\n", i);
    if (!ref_region_names[i] || strcmp(name, ref_region_names[i]))
      PUT_ERR_F(
        "yac_instrument_region_name: "
        "unexpected name for region %zu (%s vs %s)\n",
        i, name?name:"(null)",
        ref_region_names[i]?ref_region_names[i]:"(null)");
  }
}
 
static void utest_disabled_is_noop(void) {
 
  // ensure a clean, disabled starting state, regardless of test order
  yac_instrument_clear_callbacks();
 
  // with no callbacks registered, start/stop must be safe no-ops
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
}
 
static void utest_single_region(void) {
 
  instr_counters ctx = (instr_counters){0};
 
  // ensure a clean starting state, regardless of test order
  yac_instrument_clear_callbacks();
  yac_instrument_set_callbacks(
    utest_create_cb, utest_start_cb, utest_stop_cb, utest_destroy_cb, &ctx);
 
  { // test that a single region can be started/stopped, and the callbacks are
    // invoked correctly
    YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
    YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
    if (ctx.create_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
      PUT_ERR("single region: create_cb must be called exactly once\n");
    if (ctx.start_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
      PUT_ERR("single region: start_cb must be called exactly once\n");
    if (ctx.stop_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
      PUT_ERR("single region: stop_cb must be called exactly once\n");
    if (ctx.last_start_depth[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
      PUT_ERR("single region: start depth must be 0\n");
    if (ctx.last_stop_depth[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
      PUT_ERR("single region: stop depth must be 0\n");
    if (ctx.last_start_handle[YAC_INSTR_COMPUTE_TGT_FIELD] !=
        &dummy_handle_storage[YAC_INSTR_COMPUTE_TGT_FIELD])
      PUT_ERR("single region: start_cb must receive the created handle\n");
    if (ctx.last_stop_handle[YAC_INSTR_COMPUTE_TGT_FIELD] !=
        &dummy_handle_storage[YAC_INSTR_COMPUTE_TGT_FIELD])
      PUT_ERR("single region: stop_cb must receive the created handle\n");
  }
 
  { // test that re-starting/stopping the same region again must not
    // re-run create_cb (lazy registration happens only once per region ID)
    YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
    YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
    if (ctx.create_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
      PUT_ERR("single region: create_cb must not be called again\n");
    if (ctx.start_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 2)
      PUT_ERR("single region: start_cb must be called again\n");
    if (ctx.stop_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 2)
      PUT_ERR("single region: stop_cb must be called again\n");
  }
 
  { // test that clearing the callbacks must destroy the handle for the
    // resolved region, using the destroy_cb/user_data that was active when
    // the region was resolved (i.e. the first time it was started)
    yac_instrument_clear_callbacks();
 
    if (ctx.destroy_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
      PUT_ERR("single region: destroy_cb must be called exactly once\n");
    if (ctx.last_destroy_handle[YAC_INSTR_COMPUTE_TGT_FIELD] !=
        &dummy_handle_storage[YAC_INSTR_COMPUTE_TGT_FIELD])
      PUT_ERR("single region: destroy_cb must receive the created handle\n");
 
    // a region never touched must never be created/destroyed
    if (ctx.create_calls[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] != 0 ||
        ctx.destroy_calls[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] != 0)
      PUT_ERR("single region: untouched region must not be created/destroyed\n");
  }
}
 
static void utest_nested_regions(void) {
 
  instr_counters ctx = (instr_counters){0};
 
  // ensure a clean starting state, regardless of test order
  yac_instrument_clear_callbacks();
  yac_instrument_set_callbacks(
    utest_create_cb, utest_start_cb, utest_stop_cb, utest_destroy_cb, &ctx);
 
  // test that nested regions can be started/stopped, and the callbacks are
  // invoked correctly, with proper depth and handle values
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
  if (ctx.last_start_depth[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
    PUT_ERR("nested regions: outer region must start at depth 0\n");
  if (ctx.last_start_depth[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] != 1)
    PUT_ERR("nested regions: inner region must start at depth 1\n");
  if (ctx.last_stop_depth[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] != 1)
    PUT_ERR("nested regions: inner region must stop at depth 1\n");
  if (ctx.last_stop_depth[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
    PUT_ERR("nested regions: outer region must stop at depth 0\n");
 
  // each region ID gets its own handle
  if (ctx.last_start_handle[YAC_INSTR_COMPUTE_TGT_FIELD] !=
      &dummy_handle_storage[YAC_INSTR_COMPUTE_TGT_FIELD])
    PUT_ERR("nested regions: outer region has the wrong handle\n");
  if (ctx.last_start_handle[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] !=
      &dummy_handle_storage[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT])
    PUT_ERR("nested regions: inner region has the wrong handle\n");
 
  // calls must happen in proper LIFO order: outer start, inner start,
  // inner stop, outer stop (creation is interleaved with the first start
  // of each region)
  int const expected_order[] = {
    CREATE_TAG + YAC_INSTR_COMPUTE_TGT_FIELD,
    START_TAG  + YAC_INSTR_COMPUTE_TGT_FIELD,
    CREATE_TAG + YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT,
    START_TAG  + YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT,
    STOP_TAG   + YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT,
    STOP_TAG   + YAC_INSTR_COMPUTE_TGT_FIELD};
  int const n_expected =
    (int)(sizeof(expected_order) / sizeof(expected_order[0]));
 
  if (ctx.call_order_count != n_expected) {
    PUT_ERR("nested regions: unexpected number of callback invocations\n");
  } else {
    for (int i = 0; i < n_expected; ++i)
      if (ctx.call_order[i] != expected_order[i])
        PUT_ERR("nested regions: callbacks fired in the wrong order\n");
  }
 
  yac_instrument_clear_callbacks();
}
 
static void utest_deeply_nested_regions(void) {
 
  instr_counters ctx = (instr_counters){0};
 
  // ensure a clean starting state, regardless of test order
  yac_instrument_clear_callbacks();
  yac_instrument_set_callbacks(
    utest_create_cb, utest_start_cb, utest_stop_cb, utest_destroy_cb, &ctx);
 
  // test nesting of four distinct region IDs, all strictly nested inside
  // one another (depth increases by one on every start, in the order the
  // regions were opened)
  yac_instrument_region_id const id[4] = {
    YAC_INSTR_DIST_GRID_PAIR_NEW, YAC_INSTR_DIST_GRID_PAIR_DECOMP,
    YAC_INSTR_DIST_GRID_PAIR_REDIST, YAC_INSTR_GEN_PROC_SPHERE_PART};
 
  for (int i = 0; i < 4; ++i) YAC_INSTRUMENT_START(id[i]);
  for (int i = 3; i >= 0; --i) YAC_INSTRUMENT_STOP(id[i]);
 
  for (int i = 0; i < 4; ++i) {
    if (ctx.last_start_depth[id[i]] != i)
      PUT_ERR_F(
        "deeply nested regions: region %d must start at depth %d\n", i, i);
    if (ctx.last_stop_depth[id[i]] != i)
      PUT_ERR_F(
        "deeply nested regions: region %d must stop at depth %d\n", i, i);
  }
 
  // calls must happen in proper LIFO order: outermost-first on the way in,
  // innermost-first on the way out
  int expected_order[8];
  for (int i = 0; i < 4; ++i) {
    expected_order[2 * i]     = CREATE_TAG + id[i];
    expected_order[2 * i + 1] = START_TAG  + id[i];
  }
  int const n_start = 8;
  int const n_expected = n_start + 4;
  int full_expected[12];
  memcpy(full_expected, expected_order, sizeof(expected_order));
  for (int i = 0; i < 4; ++i)
    full_expected[n_start + i] = STOP_TAG + id[3 - i];
 
  if (ctx.call_order_count != n_expected) {
    PUT_ERR(
      "deeply nested regions: unexpected number of callback invocations\n");
  } else {
    for (int i = 0; i < n_expected; ++i)
      if (ctx.call_order[i] != full_expected[i])
        PUT_ERR("deeply nested regions: callbacks fired in the wrong order\n");
  }
 
  yac_instrument_clear_callbacks();
}
 
static void utest_sibling_nested_regions(void) {
 
  instr_counters ctx = (instr_counters){0};
 
  // ensure a clean starting state, regardless of test order
  yac_instrument_clear_callbacks();
  yac_instrument_set_callbacks(
    utest_create_cb, utest_start_cb, utest_stop_cb, utest_destroy_cb, &ctx);
 
  // test that two sibling regions, both nested inside the same parent but
  // not overlapping with each other, are each reported at the same depth,
  // and that the parent's depth is unaffected by either child
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);          // depth 0
 
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT);   // depth 1
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT);
 
  YAC_INSTRUMENT_START(YAC_INSTR_GEN_PROC_SPHERE_PART);       // depth 1 again
  YAC_INSTRUMENT_STOP(YAC_INSTR_GEN_PROC_SPHERE_PART);
 
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
  if (ctx.last_start_depth[YAC_INSTR_COMPUTE_TGT_FIELD] != 0 ||
      ctx.last_stop_depth[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
    PUT_ERR("sibling nested regions: parent must stay at depth 0\n");
  if (ctx.last_start_depth[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] != 1 ||
      ctx.last_stop_depth[YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT] != 1)
    PUT_ERR("sibling nested regions: first sibling must run at depth 1\n");
  if (ctx.last_start_depth[YAC_INSTR_GEN_PROC_SPHERE_PART] != 1 ||
      ctx.last_stop_depth[YAC_INSTR_GEN_PROC_SPHERE_PART] != 1)
    PUT_ERR("sibling nested regions: second sibling must run at depth 1\n");
 
  // each sibling must have been started/stopped exactly once, and the
  // parent must not have been re-created/re-started by either child
  if (ctx.start_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1 ||
      ctx.stop_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
    PUT_ERR("sibling nested regions: parent must start/stop exactly once\n");
 
  int const expected_order[] = {
    CREATE_TAG + YAC_INSTR_COMPUTE_TGT_FIELD,
    START_TAG  + YAC_INSTR_COMPUTE_TGT_FIELD,
    CREATE_TAG + YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT,
    START_TAG  + YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT,
    STOP_TAG   + YAC_INSTR_COMPUTE_TGT_FIELD_DIRECT,
    CREATE_TAG + YAC_INSTR_GEN_PROC_SPHERE_PART,
    START_TAG  + YAC_INSTR_GEN_PROC_SPHERE_PART,
    STOP_TAG   + YAC_INSTR_GEN_PROC_SPHERE_PART,
    STOP_TAG   + YAC_INSTR_COMPUTE_TGT_FIELD};
  int const n_expected =
    (int)(sizeof(expected_order) / sizeof(expected_order[0]));
 
  if (ctx.call_order_count != n_expected) {
    PUT_ERR(
      "sibling nested regions: unexpected number of callback invocations\n");
  } else {
    for (int i = 0; i < n_expected; ++i)
      if (ctx.call_order[i] != expected_order[i])
        PUT_ERR(
          "sibling nested regions: callbacks fired in the wrong order\n");
  }
 
  yac_instrument_clear_callbacks();
}
 
static void utest_reregister_destroys_old_handles(void) {
 
  instr_counters ctx_old = (instr_counters){0};
  instr_counters ctx_new = (instr_counters){0};
 
  yac_instrument_clear_callbacks();
  yac_instrument_set_callbacks(
    utest_create_cb, utest_start_cb, utest_stop_cb, utest_destroy_cb, &ctx_old);
 
  // resolve the region under the old registration (creates a handle)
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
  // switching to a new registration must destroy the old registration's
  // handle, using the OLD destroy_cb/user_data
  yac_instrument_set_callbacks(
    utest_create_cb, utest_start_cb, utest_stop_cb, utest_destroy_cb, &ctx_new);
 
  if (ctx_old.destroy_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
    PUT_ERR(
      "reregister: old registration's destroy_cb must be called once "
      "for the resolved region\n");
  if (ctx_new.destroy_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
    PUT_ERR("reregister: new registration's destroy_cb must not be called\n");
 
  // the new registration must start with a clean slate: create_cb must run
  // again for the same region ID
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
  if (ctx_new.create_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
    PUT_ERR(
      "reregister: new registration must re-run create_cb for a region "
      "already resolved under the old registration\n");
  if (ctx_old.create_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
    PUT_ERR("reregister: old registration's create_cb must not run again\n");
 
  yac_instrument_clear_callbacks();
 
  if (ctx_new.destroy_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
    PUT_ERR(
      "reregister: clearing callbacks must destroy the new registration's "
      "handle\n");
}
 
static void utest_start_only_no_stop_cb(void) {
 
  instr_counters ctx = (instr_counters){0};
 
  yac_instrument_clear_callbacks();
  // only start_cb is provided (no stop_cb) - this is a valid combination:
  // instrumentation is enabled as soon as start_cb or stop_cb is set
  yac_instrument_set_callbacks(
    utest_create_cb, utest_start_cb, NULL, utest_destroy_cb, &ctx);
 
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
  if (ctx.start_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
    PUT_ERR("start-only: start_cb must still be called\n");
  if (ctx.stop_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
    PUT_ERR("start-only: stop_cb must never be called (it is NULL)\n");
 
  // starting the same region again must succeed (i.e. the stop above did
  // pop the region off the open-region stack, even without a stop_cb to
  // observe it) and must report depth 0 again
  YAC_INSTRUMENT_START(YAC_INSTR_COMPUTE_TGT_FIELD);
  YAC_INSTRUMENT_STOP(YAC_INSTR_COMPUTE_TGT_FIELD);
 
  if (ctx.start_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 2)
    PUT_ERR("start-only: start_cb must be called again\n");
  if (ctx.last_start_depth[YAC_INSTR_COMPUTE_TGT_FIELD] != 0)
    PUT_ERR("start-only: region must be poppable and restartable at depth 0\n");
 
  yac_instrument_clear_callbacks();
 
  if (ctx.destroy_calls[YAC_INSTR_COMPUTE_TGT_FIELD] != 1)
    PUT_ERR("start-only: destroy_cb must still be called on clear\n");
}