/*

 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")

 *

 * SPDX-License-Identifier: MPL-2.0

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, you can obtain one at https://mozilla.org/MPL/2.0/.

 *

 * See the COPYRIGHT file distributed with this work for additional

 * information regarding copyright ownership.

 */

/*! \file */

#include <inttypes.h>

#include <string.h>

#include <isc/atomic.h>

#include <isc/buffer.h>

#include <isc/magic.h>

#include <isc/mem.h>

#include <isc/os.h>

#include <isc/refcount.h>

#include <isc/stats.h>

#include <isc/statsmulti.h>

#include <isc/tid.h>

#include <isc/util.h>

#define ISC_STATSMULTI_MAGIC  ISC_MAGIC('S', 'M', 'u', 'l')

#define ISC_STATSMULTI_VALID(x) ISC_MAGIC_VALID(x, ISC_STATSMULTI_MAGIC)

/*

 * Same constraint as stats.c

 */

STATIC_ASSERT(sizeof(isc_statscounter_t) <= sizeof(uint64_t),

        "Exported statistics must fit into the statistic counter size");

struct isc_statsmulti {

  unsigned int magic;

  isc_mem_t *mctx;

  isc_refcount_t references;

  int n_counters;

  int per_thread_capacity;

  int num_threads_plus_one;

  isc_atomic_statscounter_t *counters;

};

static int

to_index(isc_statsmulti_t *stats, isc_tid_t tid,

   isc_statscounter_t internal_counter) {

  int thread_id = tid + 1;

  if (thread_id >= stats->num_threads_plus_one) {

    thread_id = 0;

  }

  return thread_id * stats->per_thread_capacity + internal_counter;

}

void

isc_statsmulti_create(isc_mem_t *mctx, isc_statsmulti_t **statsp,

          int ncounters) {

  REQUIRE(statsp != NULL && *statsp == NULL);

  size_t size_in_bytes = sizeof(isc_atomic_statscounter_t) * ncounters;

  size_t rounded_up = (size_in_bytes + 63) & ~63; /* Round up to next

                 multiple of 64 */

  int per_thread_capacity = rounded_up /

          sizeof(isc_atomic_statscounter_t);

  int num_threads_plus_one = isc_tid_count() + 1;

  isc_statsmulti_t *stats = isc_mem_get(mctx, sizeof(*stats));

  *stats = (isc_statsmulti_t){

    .magic = ISC_STATSMULTI_MAGIC,

    .counters = isc_mem_cget(

      mctx, per_thread_capacity * num_threads_plus_one,

      sizeof(isc_atomic_statscounter_t)),

    .mctx = isc_mem_ref(mctx),

    .n_counters = ncounters,

    .num_threads_plus_one = num_threads_plus_one,

    .per_thread_capacity = per_thread_capacity,

    .references = ISC_REFCOUNT_INITIALIZER(1),

  };

  *statsp = stats;

}

static void

isc__statsmulti_destroy(isc_statsmulti_t *stats) {

  REQUIRE(ISC_STATSMULTI_VALID(stats));

  size_t alloc_size = stats->per_thread_capacity *

          stats->num_threads_plus_one *

          sizeof(isc_atomic_statscounter_t);

  isc_mem_put(stats->mctx, stats->counters, alloc_size);

  isc_mem_putanddetach(&stats->mctx, stats, sizeof(*stats));

}

ISC_REFCOUNT_IMPL(isc_statsmulti, isc__statsmulti_destroy);

Unexecuted instantiation: isc_statsmulti_ref

Unexecuted instantiation: isc_statsmulti_unref

Unexecuted instantiation: isc_statsmulti_detach

void

isc_statsmulti_increment(isc_statsmulti_t *stats, isc_statscounter_t counter) {

  REQUIRE(ISC_STATSMULTI_VALID(stats));

  REQUIRE(counter < stats->n_counters);

  int index = to_index(stats, isc_tid(), counter);

  if (isc_tid() == -1) {

    atomic_fetch_add_relaxed(&stats->counters[index], 1);

  } else {

    isc_atomic_statscounter_t *ptr = &stats->counters[index];

    atomic_store_relaxed(ptr, atomic_load_relaxed(ptr) + 1);

  }

}

void

isc_statsmulti_decrement(isc_statsmulti_t *stats, isc_statscounter_t counter) {

  REQUIRE(ISC_STATSMULTI_VALID(stats));

  REQUIRE(counter < stats->n_counters);

  int index = to_index(stats, isc_tid(), counter);

  if (isc_tid() == -1) {

    atomic_fetch_sub_relaxed(&stats->counters[index], 1);

  } else {

    isc_atomic_statscounter_t *ptr = &stats->counters[index];

    int_fast64_t tmp = atomic_load_relaxed(ptr);

    atomic_store_relaxed(ptr, tmp - 1);

  }

}

void

isc_statsmulti_dump(isc_statsmulti_t *stats, isc_statsmulti_dumper_t dump_fn,

        void *arg, unsigned int options) {

  REQUIRE(ISC_STATSMULTI_VALID(stats));

  for (int counter = 0; counter < stats->n_counters; counter++) {

    isc_statscounter_t total = isc_statsmulti_get_counter(stats,

                      counter);

    if ((options & ISC_STATSMULTIDUMP_VERBOSE) == 0 && total == 0) {

      continue;

    }

    dump_fn((isc_statscounter_t)counter, total, arg);

  }

}

isc_statscounter_t

isc_statsmulti_get_counter(isc_statsmulti_t *stats,

         isc_statscounter_t counter) {

  REQUIRE(ISC_STATSMULTI_VALID(stats));

  REQUIRE(counter < stats->n_counters);

  int idx_0 = to_index(stats, 0, counter);

  isc_statscounter_t total = atomic_load_acquire(&stats->counters[idx_0]);

  for (int thread = 1; thread < stats->num_threads_plus_one; thread++) {

    int index = to_index(stats, thread, counter);

    total += atomic_load_relaxed(&stats->counters[index]);

  }

  return total;

}

void

isc_statsmulti_clear(isc_statsmulti_t *stats) {

  REQUIRE(ISC_STATSMULTI_VALID(stats));

  for (int idx = 0;

       idx < stats->per_thread_capacity * stats->num_threads_plus_one;

       idx++)

  {

    atomic_store_release(&stats->counters[idx], 0);

  }

}