benchmark.c File Reference

benchmarking for various operations More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "benchmark.h"
#include <pthread.h>
#include <sys/syscall.h>

Include dependency graph for benchmark.c:

Go to the source code of this file.

Macros
#define	WRITE_BENCHMARK_OP(opname)

Functions
static void	write_benchmark_data (struct BenchmarkData *bd)
	Write benchmark data to a file. More...
static void	main_thread_destructor ()
	Called when the main thread exits and benchmark data for it was created. More...
static void	thread_destructor (void *cls)
	Called when a thread exits and benchmark data for it was created. More...
static void	make_key ()
	Initialize the thread-local variable key for benchmark data. More...
struct BenchmarkData *	get_benchmark_data (void)
	Acquire the benchmark data for the current thread, allocate if necessary. More...
struct UrlRequestData *	get_url_benchmark_data (char *url, unsigned int status)
	Get benchmark data for a URL. More...

Variables
static pthread_key_t	key
	Thread-local storage key for the benchmark data. More...
static pthread_once_t	key_once = PTHREAD_ONCE_INIT
	One-time initialization marker for key. More...

Detailed Description

benchmarking for various operations

Author

Florian Dold flo@d.nosp@m.old..nosp@m.me

Definition in file benchmark.c.

Macro Definition Documentation

WRITE_BENCHMARK_OP

#define WRITE_BENCHMARK_OP

(

opname

)

Value:

    do { \
    GNUNET_asprintf (&s, "op " #opname " count %llu time_us %llu\n", \
                     (unsigned long long) bd->opname ## _count, \
                     (unsigned long long) bd->opname ## _time.rel_value_us); \
    GNUNET_assert (GNUNET_SYSERR != GNUNET_DISK_file_write_blocking (fh, s, \
                                                                     strlen ( \
                                                                       s))); \
    GNUNET_free (s); \
} while (0)

Function Documentation

write_benchmark_data()

static void write_benchmark_data ( struct BenchmarkData *  bd )

static

Write benchmark data to a file.

Parameters

bd	the benchmark data

Definition at line 51 of file benchmark.c.

{
  struct GNUNET_DISK_FileHandle *fh;
  pid_t pid = getpid ();
  pid_t tid = syscall (SYS_gettid);
  char *benchmark_dir;
  char *s;
 
  benchmark_dir = getenv ("GNUNET_BENCHMARK_DIR");
 
  if (NULL == benchmark_dir)
    return;
 
  if (GNUNET_OK != GNUNET_DISK_directory_create (benchmark_dir))
  {
    GNUNET_break (0);
    return;
  }
 
  GNUNET_asprintf (&s, "%s/gnunet-benchmark-ops-%s-%llu-%llu.txt",
                   benchmark_dir,
                   (pid == tid) ? "main" : "thread",
                   (unsigned long long) pid,
                   (unsigned long long) tid);
 
  fh = GNUNET_DISK_file_open (s,
                              (GNUNET_DISK_OPEN_WRITE
                               | GNUNET_DISK_OPEN_TRUNCATE
                               | GNUNET_DISK_OPEN_CREATE),
                              (GNUNET_DISK_PERM_USER_READ
                               | GNUNET_DISK_PERM_USER_WRITE));
  GNUNET_assert (NULL != fh);
  GNUNET_free (s);
 
#define WRITE_BENCHMARK_OP(opname) do { \
    GNUNET_asprintf (&s, "op " #opname " count %llu time_us %llu\n", \
                     (unsigned long long) bd->opname ## _count, \
                     (unsigned long long) bd->opname ## _time.rel_value_us); \
    GNUNET_assert (GNUNET_SYSERR != GNUNET_DISK_file_write_blocking (fh, s, \
                                                                     strlen ( \
                                                                       s))); \
    GNUNET_free (s); \
} while (0)
 
  WRITE_BENCHMARK_OP (ecc_ecdh);
  WRITE_BENCHMARK_OP (ecdh_eddsa);
  WRITE_BENCHMARK_OP (ecdhe_key_create);
  WRITE_BENCHMARK_OP (ecdhe_key_get_public);
  WRITE_BENCHMARK_OP (ecdsa_ecdh);
  WRITE_BENCHMARK_OP (ecdsa_key_create);
  WRITE_BENCHMARK_OP (ecdsa_key_get_public);
  WRITE_BENCHMARK_OP (ecdsa_sign);
  WRITE_BENCHMARK_OP (ecdsa_verify);
  WRITE_BENCHMARK_OP (eddsa_ecdh);
  WRITE_BENCHMARK_OP (eddsa_key_create);
  WRITE_BENCHMARK_OP (eddsa_key_get_public);
  WRITE_BENCHMARK_OP (eddsa_sign);
  WRITE_BENCHMARK_OP (eddsa_verify);
  WRITE_BENCHMARK_OP (hash);
  WRITE_BENCHMARK_OP (hash_context_finish);
  WRITE_BENCHMARK_OP (hash_context_read);
  WRITE_BENCHMARK_OP (hash_context_start);
  WRITE_BENCHMARK_OP (hkdf);
  WRITE_BENCHMARK_OP (rsa_blind);
  WRITE_BENCHMARK_OP (rsa_private_key_create);
  WRITE_BENCHMARK_OP (rsa_private_key_get_public);
  WRITE_BENCHMARK_OP (rsa_sign_blinded);
  WRITE_BENCHMARK_OP (rsa_unblind);
  WRITE_BENCHMARK_OP (rsa_verify);
 
#undef WRITE_BENCHMARK_OP
 
  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
 
  GNUNET_asprintf (&s, "%s/gnunet-benchmark-urls-%s-%llu-%llu.txt",
                   benchmark_dir,
                   (pid == tid) ? "main" : "thread",
                   (unsigned long long) pid,
                   (unsigned long long) tid);
 
  fh = GNUNET_DISK_file_open (s,
                              (GNUNET_DISK_OPEN_WRITE
                               | GNUNET_DISK_OPEN_TRUNCATE
                               | GNUNET_DISK_OPEN_CREATE),
                              (GNUNET_DISK_PERM_USER_READ
                               | GNUNET_DISK_PERM_USER_WRITE));
  GNUNET_assert (NULL != fh);
  GNUNET_free (s);
 
  for (unsigned int i = 0; i < bd->urd_len; i++)
  {
    struct UrlRequestData *urd = &bd->urd[i];
    GNUNET_asprintf (&s,
                     "url %s status %u count %llu time_us %llu time_us_max %llu bytes_sent %llu bytes_received %llu\n",
                     urd->request_url,
                     urd->status,
                     (unsigned long long) urd->count,
                     (unsigned long long) urd->time.rel_value_us,
                     (unsigned long long) urd->time_max.rel_value_us,
                     (unsigned long long) urd->bytes_sent,
                     (unsigned long long) urd->bytes_received);
    GNUNET_assert (GNUNET_SYSERR != GNUNET_DISK_file_write_blocking (fh, s,
                                                                     strlen (
                                                                       s)));
    GNUNET_free (s);
  }
 
  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
}

References UrlRequestData::bytes_received, UrlRequestData::bytes_sent, UrlRequestData::count, fh, getenv(), GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_DISK_directory_create(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write_blocking(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, pid, GNUNET_TIME_Relative::rel_value_us, UrlRequestData::request_url, UrlRequestData::status, tid, UrlRequestData::time, UrlRequestData::time_max, BenchmarkData::urd, BenchmarkData::urd_len, and WRITE_BENCHMARK_OP.

Referenced by main_thread_destructor(), and thread_destructor().

Here is the call graph for this function:

Here is the caller graph for this function:

main_thread_destructor()

static void main_thread_destructor ( )

static

Called when the main thread exits and benchmark data for it was created.

Definition at line 166 of file benchmark.c.

{
  struct BenchmarkData *bd;
 
  bd = pthread_getspecific (key);
  if (NULL != bd)
    write_benchmark_data (bd);
}

References key, and write_benchmark_data().

Referenced by get_benchmark_data().

Here is the call graph for this function:

Here is the caller graph for this function:

thread_destructor()

static void thread_destructor ( void *  cls )

static

Called when a thread exits and benchmark data for it was created.

Parameters

cls

closure

Definition at line 182 of file benchmark.c.

{
  struct BenchmarkData *bd = cls;
 
  // main thread will be handled by atexit
  if (getpid () == (pid_t) syscall (SYS_gettid))
    return;
 
  GNUNET_assert (NULL != bd);
  write_benchmark_data (bd);
}

References GNUNET_assert, and write_benchmark_data().

Referenced by make_key().

Here is the call graph for this function:

Here is the caller graph for this function:

make_key()

static void make_key ( )

static

Initialize the thread-local variable key for benchmark data.

Definition at line 199 of file benchmark.c.

{
  (void) pthread_key_create (&key, &thread_destructor);
}

References key, and thread_destructor().

Referenced by get_benchmark_data().

Here is the call graph for this function:

Here is the caller graph for this function:

get_benchmark_data()

struct BenchmarkData* get_benchmark_data

(

void

)

Acquire the benchmark data for the current thread, allocate if necessary.

Installs handler to collect the benchmark data on thread termination.

Returns

benchmark data for the current thread

Definition at line 212 of file benchmark.c.

{
  struct BenchmarkData *bd;
 
  (void) pthread_once (&key_once, &make_key);
 
  if (NULL == (bd = pthread_getspecific (key)))
  {
    bd = GNUNET_new (struct BenchmarkData);
    (void) pthread_setspecific (key, bd);
    if (getpid () == (pid_t) syscall (SYS_gettid))
    {
      // We're the main thread!
      atexit (main_thread_destructor);
    }
  }
  return bd;
}

References GNUNET_new, key, key_once, main_thread_destructor(), and make_key().

Referenced by get_url_benchmark_data().

Here is the call graph for this function:

Here is the caller graph for this function:

get_url_benchmark_data()

struct UrlRequestData* get_url_benchmark_data	(	char *	url,
		unsigned int	status
	)

Get benchmark data for a URL.

If the URL is too long, it's truncated before looking up the corresponding benchmark data.

Statistics are bucketed by URL and status code.

Parameters

url	url to get request data for
status	http status code

Definition at line 242 of file benchmark.c.

{
  char trunc[MAX_BENCHMARK_URL_LEN];
  struct BenchmarkData *bd;
 
  if (NULL == url)
  {
    /* Should not happen unless curl barfs */
    GNUNET_break (0);
    url = "<empty>";
  }
 
  memcpy (trunc, url, MAX_BENCHMARK_URL_LEN);
  trunc[MAX_BENCHMARK_URL_LEN - 1] = 0;
 
  /* We're not interested in what's after the query string */
  for (size_t i = 0; i < strlen (trunc); i++)
  {
    if (trunc[i] == '?')
    {
      trunc[i] = 0;
      break;
    }
  }
 
  bd = get_benchmark_data ();
 
  GNUNET_assert (bd->urd_len <= bd->urd_capacity);
 
  for (unsigned int i = 0; i < bd->urd_len; i++)
  {
    if ((0 == strcmp (trunc, bd->urd[i].request_url)) &&
        (bd->urd[i].status == status))
      return &bd->urd[i];
  }
 
  {
    struct UrlRequestData urd = { 0 };
 
    memcpy (&urd.request_url, trunc, MAX_BENCHMARK_URL_LEN);
    urd.status = status;
 
    if (bd->urd_len == bd->urd_capacity)
    {
      bd->urd_capacity = 2 * (bd->urd_capacity + 1);
      bd->urd = GNUNET_realloc (bd->urd, bd->urd_capacity * sizeof(struct
                                                                   UrlRequestData));
    }
 
    bd->urd[bd->urd_len++] = urd;
    return &bd->urd[bd->urd_len - 1];
  }
}

References get_benchmark_data(), GNUNET_assert, GNUNET_break, GNUNET_realloc, MAX_BENCHMARK_URL_LEN, UrlRequestData::request_url, status, UrlRequestData::status, BenchmarkData::urd, BenchmarkData::urd_capacity, and BenchmarkData::urd_len.

Here is the call graph for this function:

Variable Documentation

key

pthread_key_t key

static

Thread-local storage key for the benchmark data.

Definition at line 37 of file benchmark.c.

Referenced by get_benchmark_data(), main_thread_destructor(), and make_key().

key_once

pthread_once_t key_once = PTHREAD_ONCE_INIT

static

One-time initialization marker for key.

Definition at line 42 of file benchmark.c.

Referenced by get_benchmark_data().