rps-test_util.h File Reference

Some utils facilitating the view into the internals for the sampler needed for evaluation. More...

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

Go to the source code of this file.

Macros
#define	TO_FILE   0
#define	to_file(file_name, ...)
	This function is used to facilitate writing important information to disk. More...
#define	to_file_w_len(file_name, len, ...)

Functions
char *	auth_key_to_string (struct GNUNET_CRYPTO_AuthKey auth_key)
struct GNUNET_CRYPTO_AuthKey	string_to_auth_key (const char *str)
struct GNUNET_DISK_FileHandle *	get_file_handle (const char *name)
	Get file handle. More...
int	close_all_files ()
	Close all files that were opened with get_file_handle. More...
char *	store_prefix_file_name (const unsigned int index, const char *prefix)
void	to_file_raw (const char *file_name, const char *buf, size_t size_buf)
void	to_file_raw_unaligned (const char *file_name, const char *buf, size_t size_buf, unsigned bits_needed)
uint32_t	fac (uint32_t x)
	Factorial. More...
uint32_t	binom (uint32_t n, uint32_t k)
	Binomial coefficient (n choose k) More...

Detailed Description

Some utils facilitating the view into the internals for the sampler needed for evaluation.

Author

Julius Bünger

Definition in file rps-test_util.h.

Macro Definition Documentation

TO_FILE

#define TO_FILE   0

Definition at line 31 of file rps-test_util.h.

to_file

#define to_file	(		file_name,
			...
	)

Value:

    do { \
    char tmp_buf[512] = ""; \
    int size; \
    if (NULL == file_name) break; \
    size = GNUNET_snprintf (tmp_buf, sizeof(tmp_buf), __VA_ARGS__); \
    if (0 > size) \
    { \
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, \
                  "Failed to create tmp_buf\n"); \
      break; \
    } \
    (void) strncat (tmp_buf, "\n", 511); \
    GNUNET_DISK_file_write (get_file_handle (file_name), \
                            tmp_buf, \
                            strnlen (tmp_buf, 512)); \
} while (0);

This function is used to facilitate writing important information to disk.

Definition at line 65 of file rps-test_util.h.

to_file_w_len

#define to_file_w_len	(		file_name,
			len,
			...
	)

Value:

                                                do { char tmp_buf [len]; \
                                                int size; \
                                                memset (tmp_buf, 0, len); \
                                                size = GNUNET_snprintf (tmp_buf, \
                                                                        sizeof( \
                                                                          tmp_buf), \
                                                                        __VA_ARGS__); \
                                                if (0 > size) \
                                                { \
                                                  GNUNET_log ( \
                                                    GNUNET_ERROR_TYPE_WARNING, \
                                                    "Failed to create tmp_buf\n"); \
                                                  break; \
                                                } \
                                                (void) strncat (tmp_buf, "\n", 2); \
                                                GNUNET_DISK_file_write ( \
                                                  get_file_handle (file_name), \
                                                  tmp_buf, \
                                                  strnlen ( \
                                                    tmp_buf, len)); \
} while (0);

Definition at line 83 of file rps-test_util.h.

Function Documentation

auth_key_to_string()

char * auth_key_to_string

(

struct GNUNET_CRYPTO_AuthKey

auth_key

)

Definition at line 380 of file rps-test_util.c.

{
  int size;
  size_t name_buf_size;
  char *end;
  char *buf;
  char *name_buf;
  size_t keylen = (sizeof(struct GNUNET_CRYPTO_AuthKey)) * 8;
 
  name_buf_size = 512 * sizeof(char);
  name_buf = GNUNET_malloc (name_buf_size);
 
  if (keylen % 5 > 0)
    keylen += 5 - keylen % 5;
  keylen /= 5;
  buf = GNUNET_malloc (keylen + 1);
 
  end = GNUNET_STRINGS_data_to_string (&(auth_key.key),
                                       sizeof(struct GNUNET_CRYPTO_AuthKey),
                                       buf,
                                       keylen);
 
  if (NULL == end)
  {
    GNUNET_free (buf);
    GNUNET_break (0);
  }
  else
  {
    *end = '\0';
  }
 
  size = GNUNET_snprintf (name_buf, name_buf_size, "sampler_el-%s", buf);
  if (0 > size)
    LOG (GNUNET_ERROR_TYPE_WARNING, "Failed to create name_buf\n");
 
  GNUNET_free (buf);
 
  return name_buf;
}

References end, GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_snprintf(), GNUNET_STRINGS_data_to_string(), GNUNET_CRYPTO_AuthKey::key, LOG, and size.

Here is the call graph for this function:

string_to_auth_key()

struct GNUNET_CRYPTO_AuthKey string_to_auth_key

(

const char *

str

)

Definition at line 426 of file rps-test_util.c.

{
  struct GNUNET_CRYPTO_AuthKey auth_key;
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (str,
                                     strlen (str),
                                     &auth_key.key,
                                     sizeof(struct GNUNET_CRYPTO_AuthKey)))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING, "Failed to convert string to data\n");
  }
 
  return auth_key;
}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_CRYPTO_AuthKey::key, and LOG.

Here is the call graph for this function:

get_file_handle()

struct GNUNET_DISK_FileHandle * get_file_handle

(

const char *

name

)

Get file handle.

If necessary, create file handle and store it with the other file handles.

Parameters

name	Name of the file

Returns

File handle

Definition at line 74 of file rps-test_util.c.

{
  struct GNUNET_HashCode hash;
  struct GNUNET_DISK_FileHandle *fh;
 
  if (NULL == open_files)
  {
    open_files = GNUNET_CONTAINER_multihashmap_create (16,
                                                       GNUNET_NO);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Created map of open files.\n");
  }
  GNUNET_CRYPTO_hash (name,
                      strlen (name),
                      &hash);
  if (NULL != (fh = GNUNET_CONTAINER_multihashmap_get (open_files,
                                                       &hash)))
    return fh;
  fh = GNUNET_DISK_file_open (name,
                              GNUNET_DISK_OPEN_WRITE
                              | GNUNET_DISK_OPEN_CREATE
                              | GNUNET_DISK_OPEN_APPEND,
                              GNUNET_DISK_PERM_USER_READ
                              | GNUNET_DISK_PERM_USER_WRITE
                              | GNUNET_DISK_PERM_GROUP_READ);
  if (NULL == fh)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Opening file `%s' failed.\n",
         name);
    GNUNET_assert (0);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_put (open_files,
                                                    &hash,
                                                    fh,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  return fh;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_APPEND, GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_YES, LOG, name, and open_files.

Here is the call graph for this function:

close_all_files()

int close_all_files

(

)

Close all files that were opened with get_file_handle.

Returns

Success of iterating over files

Definition at line 151 of file rps-test_util.c.

{
  int ret;
 
  if (NULL != open_files)
  {
    ret = GNUNET_CONTAINER_multihashmap_iterate (open_files,
                                                 close_files_iter,
                                                 NULL);
    GNUNET_CONTAINER_multihashmap_destroy (open_files);
    open_files = NULL;
    return ret;
  }
  return GNUNET_YES;
}

References close_files_iter(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_YES, open_files, and ret.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

store_prefix_file_name()

char * store_prefix_file_name	(	const unsigned int	index,
		const char *	prefix
	)

Definition at line 464 of file rps-test_util.c.

{
  int len_file_name;
  int out_size;
  char *file_name;
  char index_str[64];
 
  if (GNUNET_SYSERR == ensure_folder_exist ())
    return NULL;
  out_size = GNUNET_snprintf (index_str,
                              64,
                              "%u",
                              index);
  if ((64 < out_size) ||
      (0 > out_size) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to write string to buffer (size: %i, out_size: %i)\n",
                64,
                out_size);
  }
  len_file_name = (strlen (prefix)
                   + strlen (index_str)
                   + 11)
                  * sizeof(char);
  file_name = GNUNET_malloc (len_file_name);
  out_size = GNUNET_snprintf (file_name,
                              len_file_name,
                              "/tmp/rps/%s-%s",
                              prefix,
                              index_str);
  if ((len_file_name < out_size) ||
      (0 > out_size) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to write string to buffer (size: %i, out_size: %i)\n",
                len_file_name,
                out_size);
  }
  return file_name;
}

References ensure_folder_exist(), file_name, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_malloc, GNUNET_snprintf(), GNUNET_SYSERR, and prefix.

Here is the call graph for this function:

to_file_raw()

void to_file_raw	(	const char *	file_name,
		const char *	buf,
		size_t	size_buf
	)

Definition at line 169 of file rps-test_util.c.

{
  struct GNUNET_DISK_FileHandle *f;
  size_t size_written;
 
  if (NULL == (f = GNUNET_DISK_file_open (file_name,
                                          GNUNET_DISK_OPEN_APPEND
                                          | GNUNET_DISK_OPEN_WRITE
                                          | GNUNET_DISK_OPEN_CREATE,
                                          GNUNET_DISK_PERM_USER_READ
                                          | GNUNET_DISK_PERM_USER_WRITE
                                          | GNUNET_DISK_PERM_GROUP_READ
                                          | GNUNET_DISK_PERM_OTHER_READ)))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not able to open file %s\n",
         file_name);
    return;
  }
 
  size_written = GNUNET_DISK_file_write (f, buf, size_buf);
  if (size_buf != size_written)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Unable to write to file! (Size: %llu, size_written: %llu)\n",
         (unsigned long long) size_buf,
         (unsigned long long) size_written);
 
    if (GNUNET_YES != GNUNET_DISK_file_close (f))
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Unable to close file\n");
 
    return;
  }
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "Wrote %llu bytes raw.\n",
       (unsigned long long) size_written);
  if (GNUNET_YES != GNUNET_DISK_file_close (f))
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Unable to close file\n");
}

References removetrailingwhitespace::f, file_name, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_APPEND, GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_WARNING, GNUNET_YES, and LOG.

Referenced by to_file_raw_unaligned().

Here is the call graph for this function:

Here is the caller graph for this function:

to_file_raw_unaligned()

void to_file_raw_unaligned	(	const char *	file_name,
		const char *	buf,
		size_t	size_buf,
		unsigned	bits_needed
	)

Definition at line 213 of file rps-test_util.c.

{
  // TODO endianness!
  GNUNET_assert (size_buf >= (bits_needed / 8));
  // if (0 == num_bits_buf_unaligned)
  // {
  //  if (0 == (bits_needed % 8))
  //  {
  //    to_file_raw (file_name, buf, size_buf);
  //    return;
  //  }
  //  to_file_raw (file_name, buf, size_buf - 1);
  //  buf_unaligned = buf[size_buf - 1];
  //  num_bits_buf_unaligned = bits_needed % 8;
  //  return;
  // }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Was asked to write %u bits\n", bits_needed);
 
  char buf_write[size_buf + 1];
  const unsigned bytes_iter = (0 != bits_needed % 8 ?
                               (bits_needed / 8) + 1 :
                               bits_needed / 8);
  // TODO what if no iteration happens?
  unsigned size_buf_write = 0;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "num_bits_buf_unaligned: %u\n",
       num_bits_buf_unaligned);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "ua args: size_buf: %llu, bits_needed: %u -> iter: %u\n",
       (unsigned long long) size_buf,
       bits_needed,
       bytes_iter);
  buf_write[0] = buf_unaligned;
  /* Iterate over input bytes */
  for (unsigned i = 0; i < bytes_iter; i++)
  {
    /* Number of bits needed in this iteration - 8 for all except last iter */
    unsigned num_bits_needed_iter;
    /* Mask for bits to actually use */
    unsigned mask_bits_needed_iter;
    char byte_input;
    /* Number of bits needed to align unaligned byte */
    unsigned num_bits_to_align;
    /* Number of bits that are to be moved */
    unsigned num_bits_to_move;
    /* Mask for bytes to be moved */
    char mask_input_to_move;
    /* Masked bits to be moved */
    char bits_to_move;
    /* The amount of bits needed to fit the bits to shift to the nearest spot */
    unsigned distance_shift_bits;
    /* Shifted bits on the move */
    char bits_moving;
    /* (unaligned) byte being filled with bits */
    char byte_to_fill;
    /* mask for needed bits of the input byte that have not been moved */
    char mask_input_leftover;
    /* needed bits of the input byte that have not been moved */
    char byte_input_leftover;
    unsigned num_bits_leftover;
    // unsigned num_bits_discard;
    char byte_unaligned_new;
 
    if ((bits_needed - (i * 8)) <= 8)
    {
      /* last iteration */
      num_bits_needed_iter = bits_needed - (i * 8);
    }
    else
    {
      num_bits_needed_iter = 8;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "number of bits needed in this iteration: %u\n",
         num_bits_needed_iter);
    mask_bits_needed_iter = ((char) 1 << num_bits_needed_iter) - 1;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "mask needed bits (current iter): "B2B_PAT "\n",
         B2B (mask_bits_needed_iter));
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Unaligned byte: "B2B_PAT " (%u bits)\n",
         B2B (buf_unaligned),
         num_bits_buf_unaligned);
    byte_input = buf[i];
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "next whole input byte: "B2B_PAT "\n",
         B2B (byte_input));
    byte_input &= mask_bits_needed_iter;
    num_bits_to_align = 8 - num_bits_buf_unaligned;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "input byte, needed bits: "B2B_PAT "\n",
         B2B (byte_input));
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "number of bits needed to align unaligned bit: %u\n",
         num_bits_to_align);
    num_bits_to_move = GNUNET_MIN (num_bits_to_align, num_bits_needed_iter);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "number of bits of new byte to move: %u\n",
         num_bits_to_move);
    mask_input_to_move = ((char) 1 << num_bits_to_move) - 1;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "mask of bits of new byte to take for moving: "B2B_PAT "\n",
         B2B (mask_input_to_move));
    bits_to_move = byte_input & mask_input_to_move;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "masked bits of new byte to take for moving: "B2B_PAT "\n",
         B2B (bits_to_move));
    distance_shift_bits = num_bits_buf_unaligned;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "distance needed to shift bits to their correct spot: %u\n",
         distance_shift_bits);
    bits_moving = bits_to_move << distance_shift_bits;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "shifted, masked bits of new byte being moved: "B2B_PAT "\n",
         B2B (bits_moving));
    byte_to_fill = buf_unaligned | bits_moving;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "byte being filled: "B2B_PAT "\n",
         B2B (byte_to_fill));
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "pending bytes: %u\n",
         num_bits_buf_unaligned + num_bits_needed_iter);
    if (num_bits_buf_unaligned + num_bits_needed_iter >= 8)
    {
      /* buf_unaligned was aligned by filling
       * -> can be written to storage */
      buf_write[i] = byte_to_fill;
      size_buf_write++;
 
      /* store the leftover, unaligned bits in buffer */
      mask_input_leftover = mask_bits_needed_iter & (~mask_input_to_move);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "mask of leftover bits of new byte: "B2B_PAT "\n",
           B2B (mask_input_leftover));
      byte_input_leftover = byte_input & mask_input_leftover;
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "masked, leftover bits of new byte: "B2B_PAT "\n",
           B2B (byte_input_leftover));
      num_bits_leftover = num_bits_needed_iter - num_bits_to_move;
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "number of unaligned bits left: %u\n",
           num_bits_leftover);
      // num_bits_discard = 8 - num_bits_needed_iter;
      byte_unaligned_new = byte_input_leftover >> num_bits_to_move;
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "new unaligned byte: "B2B_PAT "\n",
           B2B (byte_unaligned_new));
      buf_unaligned = byte_unaligned_new;
      num_bits_buf_unaligned = num_bits_leftover % 8;
    }
    else
    {
      /* unaligned buffer still unaligned but 'fuller' */
      buf_unaligned = byte_to_fill;
      num_bits_buf_unaligned = (num_bits_buf_unaligned + bits_needed) % 8;
    }
  }
  to_file_raw (file_name, buf_write, size_buf_write);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
}

References B2B, B2B_PAT, buf_unaligned, file_name, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MIN, LOG, num_bits_buf_unaligned, and to_file_raw().

Here is the call graph for this function:

fac()

uint32_t fac

(

uint32_t

x

)

Factorial.

Parameters

x	Number of which to compute the factorial

Returns

Factorial of x

Definition at line 516 of file rps-test_util.c.

{
  if (1 >= x)
  {
    return x;
  }
  return x * fac (x - 1);
}

References fac().

Referenced by binom(), and fac().

Here is the call graph for this function:

Here is the caller graph for this function:

binom()

uint32_t binom	(	uint32_t	n,
		uint32_t	k
	)

Binomial coefficient (n choose k)

Parameters

n
k

Returns

Binomial coefficient of n and k

Definition at line 535 of file rps-test_util.c.

{
  // GNUNET_assert (n >= k);
  if (k > n)
    return 0;
  /* if (0 > n) return 0;  - always false */
  /* if (0 > k) return 0;  - always false */
  if (0 == k)
    return 1;
  return fac (n)
         /
         fac (k) * fac (n - k);
}

References fac().

Here is the call graph for this function: