maptestx.c

/*
 * Copyright (c) 2016--2021  Wu, Xingbo <wuxb45@gmail.com>
 *
 * All rights reserved. No warranty, explicit or implicit, provided.
 */
#define _GNU_SOURCE

#include "lib.h"
#include "kv.h"

struct priv {
  void * ref;
  u32 cpro;
  u32 cget;
  u32 cset;
  u32 vlen;
  struct kv * out;
};

#define XSA ((0))
#define XSS ((1))
#define XDA ((2))
#define XDS ((3))
#define XGA ((4))
#define XGS ((5))
#define XPA ((6))
#define XPS ((7))

  static bool
kvmap_analyze(void * const passdata[2], const u64 dt, const struct vctr * const va, struct damp * const d, char * const out)
{
  (void)passdata;
  size_t v[8];
  for (u64 i = 0; i < 8; i++)
    v[i] = vctr_get(va, i);

  const u64 nrop = v[XSA] + v[XDA] + v[XGA] + v[XPA];
  const double mops = ((double)nrop) * 1e3 / ((double)dt);
  const bool done = damp_add_test(d, mops);
  const char * const pat = " set %zu %zu del %zu %zu get %zu %zu pro %zu %zu mops %.4lf avg %.4lf ravg %.4lf\n";
  sprintf(out, pat, v[XSA], v[XSS], v[XDA], v[XDS], v[XGA], v[XGS], v[XPA], v[XPS], mops, damp_avg(d), damp_ravg(d));
  return done;
}

  static void
kvmap_batch(const struct forker_worker_info * const info,
    const struct priv * const priv, const u64 nr)
{
  const struct kvmap_api * const api = (typeof(api))info->passdata[0];
  void * const ref = priv->ref;
  struct vctr * const v = info->vctr;
  rgen_next_func next = info->rgen_next;
  const u64 nr_1 = nr - 1;

  u64 idp = next(info->gen); // 1st
  struct kv * kvp = kvss[idp];
  __builtin_prefetch(kvp, 0, 0);

  if (nr > 1) {
    idp = next(info->gen);
    __builtin_prefetch(&(kvss[idp]), 0, 0);
  }

  for (u64 i = 1; i <= nr; i++) {
    struct kv * const kv = kvp;
    kvp = kvss[idp];
    __builtin_prefetch(kvp, 0, 0);
    if (i < nr_1) {
      idp = next(info->gen);
      __builtin_prefetch(&(kvss[idp]), 0, 0);
    }
    const u32 p = ((u32)random_u64()) & 0xffffu;
    if (p < priv->cpro) {
      vctr_add1(v, XPA);
      if (kvmap_kv_probe(api, ref, kv))
        vctr_add1(v, XPS);
    } else if (p < priv->cget) {
      vctr_add1(v, XGA);
      if (kvmap_kv_get(api, ref, kv, priv->out))
        vctr_add1(v, XGS);
    } else if (p < priv->cset) {
      vctr_add1(v, XSA);
      if (kv->vlen != priv->vlen) // cppcheck-suppress duplicateConditionalAssign
        kv->vlen = priv->vlen;
      if (kvmap_kv_put(api, ref, kv))
        vctr_add1(v, XSS);
    } else {
      vctr_add1(v, XDA);
      if (kvmap_kv_del(api, ref, kv))
        vctr_add1(v, XDS);
    }
  }
}

  static void *
kvmap_worker(void * const ptr)
{
  struct forker_worker_info * const info = (typeof(info))ptr;
  srandom_u64(info->seed);
  const struct kvmap_api * const api = (typeof(api))info->passdata[0];

  struct priv p;
  const u32 pset = a2u32(info->argv[0]);
  const u32 pdel = a2u32(info->argv[1]);
  const u32 pget = a2u32(info->argv[2]);
  const u32 ppro = 100 - pset - pdel - pget;
  // scaled to 65536
  p.cpro = ppro * 65536 / 100;
  p.cget = (ppro + pget) * 65536 / 100;
  p.cset = (ppro + pget + pset) * 65536 / 100;

  p.vlen = a2u32(info->argv[3]);
  p.ref = kvmap_ref(api, info->passdata[1]);

  const u64 outlen = sizeof(struct kv) + kvmaxklen + p.vlen + 4096;
  p.out = yalloc(outlen);
  debug_assert(p.out);

  if (info->end_type == FORKER_END_TIME) {
    do {
      kvmap_batch(info, &p, 1lu << 14);
    } while (time_nsec() < info->end_magic);
  } else if (info->end_type == FORKER_END_COUNT) {
    kvmap_batch(info, &p, info->end_magic);
  }
  kvmap_unref(api, p.ref);
  free(p.out);
  return NULL;
}

#define NARGS ((4))
  static void
maptest_help_message(void)
{
  fprintf(stderr, "%s Usage: <keys-file> {api ... {rgen ... {pass ...}}}\n", __func__);
  kvmap_api_helper_message();
  forker_passes_message();
  fprintf(stderr, "%s maptest wargs[%d]: <pset> <pdel> <pget> <vlen>\n", __func__, NARGS);
  fprintf(stderr, "%s load kv samples at cpu: MAPTEST_KVLOAD_CPU=<cpu>; default:1\n", __func__);
}

  static int
test_kvmap(const int argc, char ** const argv)
{
  const struct kvmap_api * api = NULL;
  void * map = NULL;
  const int n1 = kvmap_api_helper(argc, argv, NULL, &api, &map);
  if (n1 < 0)
    return n1;

  char *pref[64] = {};
  for (int i = 0; i < n1; i++) {
    pref[i] = argv[i];
  }
  pref[n1] = NULL;

  struct pass_info pi = {};
  pi.passdata[0] = (void *)api;
  pi.passdata[1] = map;
  pi.vctr_size = 8;
  pi.wf = kvmap_worker;
  pi.af = kvmap_analyze;
  const int n2 = forker_passes(argc - n1, argv + n1, pref, &pi, NARGS);

  if (api->fprint)
    api->fprint(map, stderr);

  api->destroy(map);
  if (n2 < 0) {
    return n2;
  } else {
    return n1 + n2;
  }
}

  int
main(int argc, char ** argv)
{
  if (argc < 2) {
    maptest_help_message();
    exit(0);
  }
  const char * const loadat = getenv("MAPTEST_KVLOAD_CPU");
  if ((loadat ? kv_load_cpu(argv[1], a2u32(loadat)) : kv_load(argv[1])) == false)
    return 0;

  const bool r = forker_main(argc - 2, argv + 2, test_kvmap);
  if (r == false)
    maptest_help_message();
  kvloader_destroy();
  return 0;
}