benchmark.h File Reference

benchmarking for various operations More...

#include "gnunet_time_lib.h"

Include dependency graph for benchmark.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	UrlRequestData
	Struct for benchmark data for one URL. More...
struct	BenchmarkData
	Thread-local struct for benchmarking data. More...

Macros
#define	MAX_BENCHMARK_URL_LEN   128
	Maximum length of URLs considered for benchmarking.
#define	BENCHMARK_START(opname)   do { } while (0)
#define	BENCHMARK_END(opname)   do { } while (0)
#define	GNUNET_DECLARE_BENCHMARK_OP(opname)

Functions
struct BenchmarkData *	get_benchmark_data (void)
	Acquire the benchmark data for the current thread, allocate if necessary.
struct UrlRequestData *	get_url_benchmark_data (char *url, unsigned int status)
	Get benchmark data for a URL.

Detailed Description

benchmarking for various operations

Author

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

Definition in file benchmark.h.

Macro Definition Documentation

MAX_BENCHMARK_URL_LEN

#define MAX_BENCHMARK_URL_LEN   128

Maximum length of URLs considered for benchmarking.

Shorter URLs are simply truncated.

Definition at line 36 of file benchmark.h.

BENCHMARK_START

#define BENCHMARK_START

(

opname

)

do { } while (0)

Definition at line 57 of file benchmark.h.

BENCHMARK_END

#define BENCHMARK_END

(

opname

)

do { } while (0)

Definition at line 58 of file benchmark.h.

GNUNET_DECLARE_BENCHMARK_OP

#define GNUNET_DECLARE_BENCHMARK_OP

(

opname

)

Value:

  uint64_t opname ## _count; \
  struct GNUNET_TIME_Relative opname ## _time

Definition at line 108 of file benchmark.h.

{
  GNUNET_DECLARE_BENCHMARK_OP (ecc_ecdh);
  GNUNET_DECLARE_BENCHMARK_OP (ecdh_eddsa);
  GNUNET_DECLARE_BENCHMARK_OP (ecdhe_key_create);
  GNUNET_DECLARE_BENCHMARK_OP (ecdhe_key_get_public);
  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_ecdh);
  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_key_create);
  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_key_get_public);
  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_sign);
  GNUNET_DECLARE_BENCHMARK_OP (ecdsa_verify);
  GNUNET_DECLARE_BENCHMARK_OP (eddsa_ecdh);
  GNUNET_DECLARE_BENCHMARK_OP (eddsa_key_create);
  GNUNET_DECLARE_BENCHMARK_OP (eddsa_key_get_public);
  GNUNET_DECLARE_BENCHMARK_OP (eddsa_sign);
  GNUNET_DECLARE_BENCHMARK_OP (eddsa_verify);
  GNUNET_DECLARE_BENCHMARK_OP (hash);
  GNUNET_DECLARE_BENCHMARK_OP (hash_context_finish);
  GNUNET_DECLARE_BENCHMARK_OP (hash_context_read);
  GNUNET_DECLARE_BENCHMARK_OP (hash_context_start);
  GNUNET_DECLARE_BENCHMARK_OP (hkdf);
  GNUNET_DECLARE_BENCHMARK_OP (rsa_blind);
  GNUNET_DECLARE_BENCHMARK_OP (rsa_private_key_create);
  GNUNET_DECLARE_BENCHMARK_OP (rsa_private_key_get_public);
  GNUNET_DECLARE_BENCHMARK_OP (rsa_sign_blinded);
  GNUNET_DECLARE_BENCHMARK_OP (rsa_unblind);
  GNUNET_DECLARE_BENCHMARK_OP (rsa_verify);
 
  struct UrlRequestData *urd;
 
  unsigned int urd_len;
 
  unsigned int urd_capacity;
};
 
#undef GNUNET_DECLARE_BENCHMARK_OP
 
 
struct BenchmarkData *
get_benchmark_data (void);
 
struct UrlRequestData *
get_url_benchmark_data (char *url, unsigned int status);
 
#endif  /* BENCHMARK_H_ */

Function Documentation

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: