iodine 0.6.5 → 0.7.0

data/ext/iodine/fio_mem.h

@@ -1,143 +0,0 @@
-/*
-Copyright: Boaz Segev, 2018
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#ifndef H_FIO_MEM_H
-
-/**
- * This is a custom memory allocator the utilizes memory pools to allow for
- * concurrent memory allocations across threads.
- *
- * Allocated memory is always zeroed out and aligned on a 16 byte boundary.
- *
- * Reallocated memory is always aligned on a 16 byte boundary but it might be
- * filled with junk data after the valid data (this is true also for
- * `fio_realloc2`).
- *
- * The memory allocator assumes multiple concurrent allocation/deallocation,
- * short life spans (memory is freed shortly, but not immediately, after it was
- * allocated) and we small allocations (realloc almost always copies data).
- *
- * These assumptions allow the allocator to avoid lock contention by ignoring
- * fragmentation within a memory "block" and waiting for the whole "block" to be
- * freed before it's memory is recycled (no "free list").
- *
- * This allocator should NOT be used for objects with a long life-span, because
- * even a single persistent object will prevent the re-use of the whole memory
- * block (128Kb by default) from which it was allocated.
- *
- * A memory "block" can include any number of memory pages that are a multiple
- * of 2 (up to 1Mb of memory). However, the default value, set by
- * MEMORY_BLOCK_SIZE, is either 128Kb (set at th end of this header).
- *
- * Each block includes a header that uses reference counters and position
- * markers.
- *
- * The position marker (`pos`) marks the next available byte (counted in
- * multiples of 16).
- *
- * The reference counter (`ref`) counts how many pointers reference memory in
- * the block (including the "arena" that "owns" the block).
- *
- * Except for the position marker (`pos`) that acts the same as `sbrk`, there's
- * no way to know which "slices" are allocated and which "slices" are available.
- *
- * Small allocations are differentiated by their memory alignment. If a memory
- * allocation is placed 8 bytes after whole block alignment, the memory was
- * allocated directly using `mmap` (and it might be using a whole page more than
- * request, just because it needed that extra header space!).
- *
- * The allocator uses `mmap` when requesting memory from the system and for
- * allocations bigger than MEMORY_BLOCK_ALLOC_LIMIT (37.5% of the block).
- *
- * To replace the system's `malloc` function family compile with the
- * `FIO_OVERRIDE_MALLOC` defined (`-DFIO_OVERRIDE_MALLOC`).
- *
- * When using tcmalloc or jemalloc, define `FIO_FORCE_MALLOC` to prevent
- * `fio_mem` from compiling (`-DFIO_FORCE_MALLOC`). Function wrappers will be
- * compiled just in case, so calls to `fio_malloc` will be routed to `malloc`.
- *
- */
-#define H_FIO_MEM_H
-
-#include <stdlib.h>
-
-/** Allocates memory using a per-CPU core block memory pool. */
-void *fio_malloc(size_t size);
-
-/** Allocates memory using a per-CPU core block memory pool. memory is zeroed
- * out. */
-void *fio_calloc(size_t size, size_t count);
-
-/** Frees memory that was allocated using this library. */
-void fio_free(void *ptr);
-
-/**
- * Re-allocates memory. An attept to avoid copying the data is made only for
- * memory allocations larger than 64Kb.
- */
-void *fio_realloc(void *ptr, size_t new_size);
-
-/**
- * Re-allocates memory. An attept to avoid copying the data is made only for
- * memory allocations larger than 64Kb.
- *
- * This variation is slightly faster as it might copy less data.
- */
-void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length);
-
-/** Clears any memory locks, in case of a system call to `fork`. */
-void fio_malloc_after_fork(void);
-
-/** Tests the facil.io memory allocator. */
-void fio_malloc_test(void);
-
-/** If defined, `malloc` will be used instead of the fio_malloc functions */
-#if FIO_FORCE_MALLOC
-#define fio_malloc malloc
-#define fio_calloc calloc
-#define fio_free free
-#define fio_realloc realloc
-#define fio_realloc2(ptr, new_size, old_data_len) realloc((ptr), (new_size))
-#define fio_malloc_test()
-#define fio_malloc_after_fork
-
-/* allows local override as well as global override */
-#elif FIO_OVERRIDE_MALLOC
-#define malloc fio_malloc
-#define free fio_free
-#define realloc fio_realloc
-#define calloc fio_calloc
-
-#endif
-
-#ifndef FIO_MEM_MAX_BLOCKS_PER_CORE
-/**
- * The maximum number of available memory blocks that will be pooled before
- * memory is returned to the system.
- */
-#define FIO_MEM_MAX_BLOCKS_PER_CORE 32 /* approx. 2Mb per CPU core */
-#endif
-
-/** Allocator default settings. */
-#ifndef FIO_MEMORY_BLOCK_SIZE_LOG
-#define FIO_MEMORY_BLOCK_SIZE_LOG (17) /* 17 == 128Kb */
-#endif
-#ifndef FIO_MEMORY_BLOCK_SIZE
-#define FIO_MEMORY_BLOCK_SIZE ((uintptr_t)1 << FIO_MEMORY_BLOCK_SIZE_LOG)
-#endif
-#ifndef FIO_MEMORY_BLOCK_MASK
-#define FIO_MEMORY_BLOCK_MASK (FIO_MEMORY_BLOCK_SIZE - 1) /* 0b111... */
-#endif
-#ifndef FIO_MEMORY_BLOCK_SLICES
-#define FIO_MEMORY_BLOCK_SLICES (FIO_MEMORY_BLOCK_SIZE >> 4) /* 16B/slice */
-#endif
-#ifndef FIO_MEMORY_BLOCK_ALLOC_LIMIT
-/* defaults to 37.5% of the block */
-#define FIO_MEMORY_BLOCK_ALLOC_LIMIT                                           \
-  ((FIO_MEMORY_BLOCK_SIZE >> 2) + (FIO_MEMORY_BLOCK_SIZE >> 3))
-#endif
-
-#endif /* H_FIO_MEM_H */

data/ext/iodine/fio_random.c

@@ -1,248 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2018
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include "fio_random.h"
-
-#include <errno.h>
-#include <stdio.h>
-
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-
-/* include intrinsics if supported */
-#if __has_include(<x86intrin.h>)
-#include <x86intrin.h>
-#define HAVE_X86Intrin
-/*
-see: https://software.intel.com/en-us/node/513411
-and: https://software.intel.com/sites/landingpage/IntrinsicsGuide/
-*/
-#endif /* __has_include(<x86intrin.h>) */
-
-/* check for unix support */
-#if defined(__unix__) || defined(__linux__) || defined(__APPLE__) ||           \
-    (__has_include(<unistd.h>) && __has_include(<pthread.h>))
-#ifndef HAS_UNIX_FEATURES
-#define HAS_UNIX_FEATURES
-#endif
-#endif
-
-// clang-format off
-#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
-#   if defined(__has_include)
-#     if __has_include(<endian.h>)
-#      include <endian.h>
-#     elif __has_include(<sys/endian.h>)
-#      include <sys/endian.h>
-#     endif
-#   endif
-#   if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) && \
-                __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#      define __BIG_ENDIAN__
-#   endif
-#endif
-// clang-format on
-
-#if defined(USE_ALT_RANDOM) || !defined(HAS_UNIX_FEATURES)
-#include "fio_sha2.h"
-#include <time.h>
-#include <string.h>
-
-static inline void fio_random_data(sha2_s *sha2) {
-#ifdef RUSAGE_SELF
-  struct rusage rusage;
-  getrusage(RUSAGE_SELF, &rusage);
-  fio_sha2_write(sha2, &rusage, sizeof(rusage));
-#elif defined CLOCKS_PER_SEC
-  size_t clk = (size_t)clock();
-  fio_sha2_write(&sha2, &clk, sizeof(clk));
-  time_t the_time;
-  time(&the_time);
-  fio_sha2_write(sha2, &the_time, sizeof(the_time));
-  fio_sha2_write(sha2, &fio_rand64, sizeof(void *));
-  fio_sha2_write(sha2, &fio_rand_bytes, sizeof(void *));
-  {
-    char junk_data[64];
-    fio_sha2_write(sha2, junk_data, 64);
-  }
-#else
-#error Random alternative failed to find access to the CPU clock state.
-#endif
-  fio_sha2_write(sha2, sha2, sizeof(void *));
-}
-
-uint32_t fio_rand32(void) {
-  sha2_s sha2 = fio_sha2_init(SHA_512);
-  fio_random_data(&sha2);
-  fio_sha2_result(&sha2);
-  return *((uint32_t *)sha2.buffer);
-}
-
-uint64_t fio_rand64(void) {
-  sha2_s sha2 = fio_sha2_init(SHA_512);
-  fio_random_data(&sha2);
-  fio_sha2_result(&sha2);
-  return *((uint64_t *)sha2.buffer);
-}
-
-void fio_rand_bytes(void *target, size_t length) {
-  sha2_s sha2 = fio_sha2_init(SHA_512);
-  fio_random_data(&sha2);
-  fio_sha2_result(&sha2);
-
-  while (length >= 64) {
-    memcpy(target, sha2.digest.str, 64);
-    length -= 64;
-    target = (void *)((uintptr_t)target + 64);
-    fio_random_data(&sha2);
-    fio_sha2_result(&sha2);
-  }
-  if (length >= 32) {
-    memcpy(target, sha2.digest.str, 32);
-    length -= 32;
-    target = (void *)((uintptr_t)target + 32);
-    fio_random_data(&sha2);
-    fio_sha2_result(&sha2);
-  }
-  if (length >= 16) {
-    memcpy(target, sha2.digest.str, 16);
-    length -= 16;
-    target = (void *)((uintptr_t)target + 16);
-    fio_random_data(&sha2);
-    fio_sha2_result(&sha2);
-  }
-  if (length >= 8) {
-    memcpy(target, sha2.digest.str, 8);
-    length -= 8;
-    target = (void *)((uintptr_t)target + 8);
-    fio_random_data(&sha2);
-    fio_sha2_result(&sha2);
-  }
-  while (length) {
-    *((uint8_t *)target) = sha2.digest.str[length];
-    target = (void *)((uintptr_t)target + 1);
-    --length;
-  }
-}
-
-#else
-/* ***************************************************************************
-Unix Random Engine (use built in machine)
-*/
-#include <errno.h>
-#include <fcntl.h>
-#include <pthread.h>
-#include <unistd.h>
-
-/* ***************************************************************************
-Machine specific changes
-*/
-// #ifdef __linux__
-// #undef bswap16
-// #undef bswap32
-// #undef bswap64
-// #include <machine/bswap.h>
-// #endif
-#ifdef HAVE_X86Intrin
-// #undef bswap16
-/*
-#undef bswap32
-#define bswap32(i) \
-  { __asm__("bswap %k0" : "+r"(i) :); }
-*/
-#undef bswap64
-#define bswap64(i)                                                             \
-  { __asm__("bswapq %0" : "+r"(i) :); }
-
-// shadow sched_yield as _mm_pause for spinwait
-#define sched_yield() _mm_pause()
-#endif
-
-/* ***************************************************************************
-Random fd
-***************************************************************************** */
-
-/* rand generator management */
-static int fio_rand_fd_ = -1;
-static void close_rand_fd(void) {
-  if (fio_rand_fd_ >= 0)
-    close(fio_rand_fd_);
-  fio_rand_fd_ = -1;
-}
-static void init_rand_fd(void) {
-  if (fio_rand_fd_ < 0) {
-    while ((fio_rand_fd_ = open("/dev/urandom", O_RDONLY)) == -1) {
-      if (errno == ENXIO) {
-        perror("FATAL ERROR: caanot initiate random generator");
-        exit(-1);
-      }
-      sched_yield();
-    }
-  }
-  atexit(close_rand_fd);
-}
-
-/* ***************************************************************************
-Random API ... (why is this not a system call?)
-***************************************************************************** */
-
-/* rand function template */
-#define MAKE_RAND_FUNC(type, func_name)                                        \
-  type func_name(void) {                                                       \
-    if (fio_rand_fd_ < 0)                                                      \
-      init_rand_fd();                                                          \
-    type ret;                                                                  \
-    while (read(fio_rand_fd_, &ret, sizeof(type)) < 0)                         \
-      sched_yield();                                                           \
-    return ret;                                                                \
-  }
-/* rand functions */
-MAKE_RAND_FUNC(uint32_t, fio_rand32)
-MAKE_RAND_FUNC(uint64_t, fio_rand64)
-/* clear template */
-#undef MAKE_RAND_FUNC
-
-void fio_rand_bytes(void *target, size_t length) {
-  if (fio_rand_fd_ < 0)
-    init_rand_fd();
-  while (read(fio_rand_fd_, target, length) < 0)
-    sched_yield();
-}
-#endif /* Unix Random */
-
-/*******************************************************************************
-Random Testing
-***************************************************************************** */
-#if DEBUG
-void fio_random_test(void) {
-  uint64_t buffer[8];
-  clock_t start, end;
-  fio_rand64();
-  start = clock();
-  for (size_t i = 0; i < 100000; i++) {
-    buffer[i & 7] = fio_rand64();
-  }
-  end = clock();
-  fprintf(stderr,
-          "+ Random generator available\n+ created 100K X 64bits "
-          "Random %lu CPU clock count\n",
-          end - start);
-  start = clock();
-  for (size_t i = 0; i < 100000; i++) {
-    fio_rand_bytes(buffer, 64);
-  }
-  end = clock();
-  fprintf(stderr,
-          "+ created 100K X 512bits "
-          "Random %lu CPU clock count\n",
-          end - start);
-}
-#endif

data/ext/iodine/fio_random.h

@@ -1,45 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#ifndef fio_RANDOM_H
-#define fio_RANDOM_H
-/* *****************************************************************************
-C++ extern
-*/
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/* ***************************************************************************
-Random stuff... (why is this not a system call?)
-*/
-
-/** returns 32 random bits. */
-uint32_t fio_rand32(void);
-
-/** returns 64 random bits. */
-uint64_t fio_rand64(void);
-
-/** returns a variable length string of random bytes. */
-void fio_rand_bytes(void *target, size_t length);
-
-#if DEBUG
-void fio_random_test(void);
-#endif
-
-/* *****************************************************************************
-C++ extern finish
-*/
-#if defined(__cplusplus)
-}
-#endif
-
-#endif

data/ext/iodine/fio_sha1.c

@@ -1,362 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include "fio_sha1.h"
-
-#include <string.h>
-
-/*****************************************************************************
-Useful Macros - Not all of them are used here, but it's a copy-paste convenience
-*/
-
-/** 32Bit left rotation, inlined. */
-#define left_rotate32(i, bits)                                                 \
-  (((uint32_t)(i) << (bits)) | ((uint32_t)(i) >> (32 - (bits))))
-/** 32Bit right rotation, inlined. */
-#define right_rotate32(i, bits)                                                \
-  (((uint32_t)(i) >> (bits)) | ((uint32_t)(i) << (32 - (bits))))
-/** 64Bit left rotation, inlined. */
-#define left_rotate64(i, bits)                                                 \
-  (((uint64_t)(i) << (bits)) | ((uint64_t)(i) >> (64 - (bits))))
-/** 64Bit right rotation, inlined. */
-#define right_rotate64(i, bits)                                                \
-  (((uint64_t)(i) >> (bits)) | ((uint64_t)(i) << (64 - (bits))))
-/** unknown size element - left rotation, inlined. */
-#define left_rotate(i, bits) (((i) << (bits)) | ((i) >> (sizeof((i)) - (bits))))
-/** unknown size element - right rotation, inlined. */
-#define right_rotate(i, bits)                                                  \
-  (((i) >> (bits)) | ((i) << (sizeof((i)) - (bits))))
-/** inplace byte swap 16 bit integer */
-#define bswap16(i)                                                             \
-  do {                                                                         \
-    (i) = (((i)&0xFFU) << 8) | (((i)&0xFF00U) >> 8);                           \
-  } while (0);
-/** inplace byte swap 32 bit integer */
-#define bswap32(i)                                                             \
-  do {                                                                         \
-    (i) = (((i)&0xFFUL) << 24) | (((i)&0xFF00UL) << 8) |                       \
-          (((i)&0xFF0000UL) >> 8) | (((i)&0xFF000000UL) >> 24);                \
-  } while (0);
-/** inplace byte swap 64 bit integer */
-#define bswap64(i)                                                             \
-  do {                                                                         \
-    (i) = (((i)&0xFFULL) << 56) | (((i)&0xFF00ULL) << 40) |                    \
-          (((i)&0xFF0000ULL) << 24) | (((i)&0xFF000000ULL) << 8) |             \
-          (((i)&0xFF00000000ULL) >> 8) | (((i)&0xFF0000000000ULL) >> 24) |     \
-          (((i)&0xFF000000000000ULL) >> 40) |                                  \
-          (((i)&0xFF00000000000000ULL) >> 56);                                 \
-  } while (0);
-
-static const uint8_t sha1_padding[64] = {0x80, 0};
-
-#ifdef __BIG_ENDIAN__
-/** Converts a 4 byte string to a uint32_t word. careful with alignment! */
-#define str2word(c) (*((uint32_t *)(c)))
-#else
-/**
-Converts a 4 byte string to a Big Endian uint32_t word. (ignores alignment!)
-*/
-#define str2word(c)                                                            \
-  (((*((uint32_t *)(c))) & 0xFFUL) << 24) |                                    \
-      (((*((uint32_t *)(c))) & 0xFF00UL) << 8) |                               \
-      (((*((uint32_t *)(c))) & 0xFF0000UL) >> 8) |                             \
-      (((*((uint32_t *)(c))) & 0xFF000000UL) >> 24)
-#endif
-/**
-Process the buffer once full.
-*/
-static inline void perform_all_rounds(sha1_s *s, const uint8_t *buffer) {
-  /* collect data */
-  uint32_t a = s->digest.i[0];
-  uint32_t b = s->digest.i[1];
-  uint32_t c = s->digest.i[2];
-  uint32_t d = s->digest.i[3];
-  uint32_t e = s->digest.i[4];
-  uint32_t t, w[16];
-  /* copy data to words, performing byte swapping as needed */
-  w[0] = str2word(buffer);
-  w[1] = str2word(buffer + 4);
-  w[2] = str2word(buffer + 8);
-  w[3] = str2word(buffer + 12);
-  w[4] = str2word(buffer + 16);
-  w[5] = str2word(buffer + 20);
-  w[6] = str2word(buffer + 24);
-  w[7] = str2word(buffer + 28);
-  w[8] = str2word(buffer + 32);
-  w[9] = str2word(buffer + 36);
-  w[10] = str2word(buffer + 40);
-  w[11] = str2word(buffer + 44);
-  w[12] = str2word(buffer + 48);
-  w[13] = str2word(buffer + 52);
-  w[14] = str2word(buffer + 56);
-  w[15] = str2word(buffer + 60);
-/* perform rounds */
-#define perform_single_round(num)                                              \
-  t = left_rotate32(a, 5) + e + w[num] + ((b & c) | ((~b) & d)) + 0x5A827999;  \
-  e = d;                                                                       \
-  d = c;                                                                       \
-  c = left_rotate32(b, 30);                                                    \
-  b = a;                                                                       \
-  a = t;
-
-#define perform_four_rounds(i)                                                 \
-  perform_single_round(i);                                                     \
-  perform_single_round(i + 1);                                                 \
-  perform_single_round(i + 2);                                                 \
-  perform_single_round(i + 3);
-
-  perform_four_rounds(0);
-  perform_four_rounds(4);
-  perform_four_rounds(8);
-  perform_four_rounds(12);
-
-#undef perform_single_round
-#define perform_single_round(i)                                                \
-  w[(i)&15] = left_rotate32((w[(i - 3) & 15] ^ w[(i - 8) & 15] ^               \
-                             w[(i - 14) & 15] ^ w[(i - 16) & 15]),             \
-                            1);                                                \
-  t = left_rotate32(a, 5) + e + w[(i)&15] + ((b & c) | ((~b) & d)) +           \
-      0x5A827999;                                                              \
-  e = d;                                                                       \
-  d = c;                                                                       \
-  c = left_rotate32(b, 30);                                                    \
-  b = a;                                                                       \
-  a = t;
-
-  perform_four_rounds(16);
-
-#undef perform_single_round
-#define perform_single_round(i)                                                \
-  w[(i)&15] = left_rotate32((w[(i - 3) & 15] ^ w[(i - 8) & 15] ^               \
-                             w[(i - 14) & 15] ^ w[(i - 16) & 15]),             \
-                            1);                                                \
-  t = left_rotate32(a, 5) + e + w[(i)&15] + (b ^ c ^ d) + 0x6ED9EBA1;          \
-  e = d;                                                                       \
-  d = c;                                                                       \
-  c = left_rotate32(b, 30);                                                    \
-  b = a;                                                                       \
-  a = t;
-
-  perform_four_rounds(20);
-  perform_four_rounds(24);
-  perform_four_rounds(28);
-  perform_four_rounds(32);
-  perform_four_rounds(36);
-
-#undef perform_single_round
-#define perform_single_round(i)                                                \
-  w[(i)&15] = left_rotate32((w[(i - 3) & 15] ^ w[(i - 8) & 15] ^               \
-                             w[(i - 14) & 15] ^ w[(i - 16) & 15]),             \
-                            1);                                                \
-  t = left_rotate32(a, 5) + e + w[(i)&15] + ((b & (c | d)) | (c & d)) +        \
-      0x8F1BBCDC;                                                              \
-  e = d;                                                                       \
-  d = c;                                                                       \
-  c = left_rotate32(b, 30);                                                    \
-  b = a;                                                                       \
-  a = t;
-
-  perform_four_rounds(40);
-  perform_four_rounds(44);
-  perform_four_rounds(48);
-  perform_four_rounds(52);
-  perform_four_rounds(56);
-#undef perform_single_round
-#define perform_single_round(i)                                                \
-  w[(i)&15] = left_rotate32((w[(i - 3) & 15] ^ w[(i - 8) & 15] ^               \
-                             w[(i - 14) & 15] ^ w[(i - 16) & 15]),             \
-                            1);                                                \
-  t = left_rotate32(a, 5) + e + w[(i)&15] + (b ^ c ^ d) + 0xCA62C1D6;          \
-  e = d;                                                                       \
-  d = c;                                                                       \
-  c = left_rotate32(b, 30);                                                    \
-  b = a;                                                                       \
-  a = t;
-  perform_four_rounds(60);
-  perform_four_rounds(64);
-  perform_four_rounds(68);
-  perform_four_rounds(72);
-  perform_four_rounds(76);
-
-  /* store data */
-  s->digest.i[4] += e;
-  s->digest.i[3] += d;
-  s->digest.i[2] += c;
-  s->digest.i[1] += b;
-  s->digest.i[0] += a;
-}
-
-/* ***************************************************************************
-SHA-1 hashing
-*/
-
-/**
-Initialize or reset the `sha1` object. This must be performed before hashing
-data using sha1.
-*/
-sha1_s fio_sha1_init(void) {
-  return (sha1_s){.digest.i[0] = 0x67452301,
-                  .digest.i[1] = 0xefcdab89,
-                  .digest.i[2] = 0x98badcfe,
-                  .digest.i[3] = 0x10325476,
-                  .digest.i[4] = 0xc3d2e1f0};
-}
-
-/**
-Writes data to the sha1 buffer.
-*/
-void fio_sha1_write(sha1_s *s, const void *data, size_t len) {
-  size_t in_buffer = s->length & 63;
-  size_t partial = 64 - in_buffer;
-  s->length += len;
-  if (partial > len) {
-    memcpy(s->buffer + in_buffer, data, len);
-    return;
-  }
-  if (in_buffer) {
-    memcpy(s->buffer + in_buffer, data, partial);
-    len -= partial;
-    data = (void *)((uintptr_t)data + partial);
-    perform_all_rounds(s, s->buffer);
-  }
-  while (len >= 64) {
-    perform_all_rounds(s, data);
-    data = (void *)((uintptr_t)data + 64);
-    len -= 64;
-  }
-  if (len) {
-    memcpy(s->buffer + in_buffer, data, len);
-  }
-  return;
-}
-
-char *fio_sha1_result(sha1_s *s) {
-  size_t in_buffer = s->length & 63;
-  if (in_buffer > 55) {
-    memcpy(s->buffer + in_buffer, sha1_padding, 64 - in_buffer);
-    perform_all_rounds(s, s->buffer);
-    memcpy(s->buffer, sha1_padding + 1, 56);
-  } else if (in_buffer != 55) {
-    memcpy(s->buffer + in_buffer, sha1_padding, 56 - in_buffer);
-  } else {
-    s->buffer[55] = sha1_padding[0];
-  }
-  /* store the length in BITS - alignment should be promised by struct */
-  /* this must the number in BITS, encoded as a BIG ENDIAN 64 bit number */
-  uint64_t *len = (uint64_t *)(s->buffer + 56);
-  *len = s->length << 3;
-#ifndef __BIG_ENDIAN__
-  bswap64(*len);
-#endif
-  perform_all_rounds(s, s->buffer);
-
-/* change back to little endian, if required */
-#ifndef __BIG_ENDIAN__
-  bswap32(s->digest.i[0]);
-  bswap32(s->digest.i[1]);
-  bswap32(s->digest.i[2]);
-  bswap32(s->digest.i[3]);
-  bswap32(s->digest.i[4]);
-#endif
-  // fprintf(stderr, "result requested, in hex, is:");
-  // for (size_t i = 0; i < 20; i++)
-  //   fprintf(stderr, "%02x", (unsigned int)(s->digest.str[i] & 0xFF));
-  // fprintf(stderr, "\r\n");
-  return (char *)s->digest.str;
-}
-
-/*******************************************************************************
-SHA-1 testing
-*/
-#if defined(DEBUG) && DEBUG == 1
-#include <stdio.h>
-#include <time.h>
-
-// clang-format off
-#if defined(HAVE_OPENSSL)
-#  include <openssl/sha.h>
-#endif
-// clang-format on
-
-void fio_sha1_test(void) {
-  struct {
-    char *str;
-    uint8_t hash[21];
-  } sets[] = {
-      {"The quick brown fox jumps over the lazy dog",
-       {0x2f, 0xd4, 0xe1, 0xc6, 0x7a, 0x2d, 0x28, 0xfc, 0xed, 0x84, 0x9e,
-        0xe1, 0xbb, 0x76, 0xe7, 0x39, 0x1b, 0x93, 0xeb, 0x12, 0}}, // a set with
-                                                                   // a string
-      {"",
-       {
-           0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55,
-           0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09,
-       }},        // an empty set
-      {NULL, {0}} // Stop
-  };
-  int i = 0;
-  sha1_s sha1;
-  fprintf(stderr, "===================================\n");
-  fprintf(stderr, "fio SHA-1 struct size: %zu\n", sizeof(sha1_s));
-  fprintf(stderr, "+ fio");
-  while (sets[i].str) {
-    sha1 = fio_sha1_init();
-    fio_sha1_write(&sha1, sets[i].str, strlen(sets[i].str));
-    if (strcmp(fio_sha1_result(&sha1), (char *)sets[i].hash)) {
-      fprintf(stderr, ":\n--- fio SHA-1 Test FAILED!\nstring: %s\nexpected: ",
-              sets[i].str);
-      char *p = (char *)sets[i].hash;
-      while (*p)
-        fprintf(stderr, "%02x", *(p++) & 0xFF);
-      fprintf(stderr, "\ngot: ");
-      p = fio_sha1_result(&sha1);
-      while (*p)
-        fprintf(stderr, "%02x", *(p++) & 0xFF);
-      fprintf(stderr, "\n");
-      return;
-    }
-    i++;
-  }
-  fprintf(stderr, " SHA-1 passed.\n");
-
-#ifdef HAVE_OPENSSL
-  fprintf(stderr, "===================================\n");
-  fprintf(stderr, "fio SHA-1 struct size: %lu\n",
-          (unsigned long)sizeof(sha1_s));
-  fprintf(stderr, "OpenSSL SHA-1 struct size: %lu\n",
-          (unsigned long)sizeof(SHA_CTX));
-  fprintf(stderr, "===================================\n");
-
-  unsigned char hash[SHA512_DIGEST_LENGTH + 1];
-  hash[SHA512_DIGEST_LENGTH] = 0;
-  clock_t start;
-  start = clock();
-  for (i = 0; i < 100000; i++) {
-    sha1 = fio_sha1_init();
-    fio_sha1_write(&sha1, "The quick brown fox jumps over the lazy dog ", 43);
-    fio_sha1_result(&sha1);
-  }
-  fprintf(stderr, "fio 100K SHA-1: %lf\n",
-          (double)(clock() - start) / CLOCKS_PER_SEC);
-
-  hash[SHA_DIGEST_LENGTH] = 0;
-  SHA_CTX o_sh1;
-  start = clock();
-  for (i = 0; i < 100000; i++) {
-    SHA1_Init(&o_sh1);
-    SHA1_Update(&o_sh1, "The quick brown fox jumps over the lazy dog", 43);
-    SHA1_Final(hash, &o_sh1);
-  }
-  fprintf(stderr, "OpenSSL 100K SHA-1: %lf\n",
-          (double)(clock() - start) / CLOCKS_PER_SEC);
-
-#endif
-}
-#endif