engine.c File Reference

#include "serene/rt/engine.h"
#include "serene/rt/context.h"
#include "serene/rt/fiber.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/mm/interface.h"
#include "serene/rt/reactor.h"
#include "serene/utils.h"
#include <assert.h>
#include <signal.h>
#include <string.h>
#include "third_party/xxhash.h"

Include dependency graph for engine.c:

Go to the source code of this file.

Macros
#define	XXH_INLINE_ALL
#define	XXH_STATIC_LINKING_ONLY
#define	XXH_ENABLE_AUTOVECTORIZE
#define	XXH_NO_STDLIB
#define	XXH_NO_XXH3
#define	XXH_NO_LONG_LONG
#define	XXH_NO_STREAM
#define	XXH_IMPLEMENTATION

Functions
static srn_seed_t	srn_generate_seed ()
srn_engine_t *	srn_engine_make (srn_mm_t *mm, const srn_configuration_t *config)
	Create the engine over mm, copying config (the runtime's knobs) into it.
void	srn_engine_shutdown (srn_engine_t *engine)
srn_hash_t	srn_hash (const srn_engine_t *engine, const void *data, size_t len)
srn_object_id_t	srn_allocate_object_id (srn_engine_t *engine)

Macro Definition Documentation

XXH_ENABLE_AUTOVECTORIZE

#define XXH_ENABLE_AUTOVECTORIZE

Definition at line 42 of file engine.c.

XXH_IMPLEMENTATION

#define XXH_IMPLEMENTATION

Definition at line 49 of file engine.c.

XXH_INLINE_ALL

#define XXH_INLINE_ALL

Definition at line 40 of file engine.c.

XXH_NO_LONG_LONG

#define XXH_NO_LONG_LONG

Definition at line 47 of file engine.c.

XXH_NO_STDLIB

#define XXH_NO_STDLIB

Definition at line 44 of file engine.c.

XXH_NO_STREAM

#define XXH_NO_STREAM

Definition at line 48 of file engine.c.

XXH_NO_XXH3

#define XXH_NO_XXH3

Definition at line 46 of file engine.c.

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

Definition at line 41 of file engine.c.

Function Documentation

srn_allocate_object_id()

srn_object_id_t srn_allocate_object_id

(

srn_engine_t *

engine

)

Definition at line 172 of file engine.c.

                                                             {
  PANIC_IF_NULL(engine);
  return atomic_fetch_add_explicit(&engine->object_id_counter, 1, memory_order_relaxed);
}

Here is the caller graph for this function:

srn_engine_make()

srn_engine_t * srn_engine_make	(	srn_mm_t *	mm,
		const srn_configuration_t *	config )

Create the engine over mm, copying config (the runtime's knobs) into it.

Pass nullptr for config to use the defaults. config is read only during the call, so the caller may pass a stack value.

Definition at line 101 of file engine.c.

                                                                               {
  PANIC_IF_NULL(mm);
  srn_engine_t *engine = srn_mm_immortal_allocate(mm, srn_engine_t);
 
  if (engine == nullptr) {
    return nullptr;
  }
 
  // A null `config` means "use the defaults"; otherwise copy the caller's
  // knobs. Either way the engine owns its copy, so the caller's `config` need
  // not outlive this call. Validating the copy makes a bad knob fail loudly
  // here, before anything is sized or bounded by it.
  engine->config = (config != nullptr) ? *config : SRN_CONFIG_DEFAULTS;
  srn_config_validate(&engine->config);
 
  engine->seed = srn_generate_seed();
  // Just reserving 0..100 for any unpredicted needs
  engine->mm = mm;
 
#if !defined(_WIN32)
  // A fiber writing to a peer that has closed its end would otherwise raise
  // SIGPIPE and take the whole process down. The reactor's WRITE path uses
  // write(), which cannot pass MSG_NOSIGNAL, so suppress SIGPIPE process-wide
  // and let the operation fail with -EPIPE instead. Idempotent across engines.
  // Something to have a look at:
  // https://stackoverflow.com/questions/8369506/why-does-sigpipe-exist
  // Also since we're ignoring sigpipe here permanently, we can safely ignore
  // the returning previous signal handler by the signal function call
  UNUSED(signal(SIGPIPE, SIG_IGN));
#endif
 
#ifdef SRN_WITH_SERENE
  engine->jit = srn_jit_make(mm);
#endif
  engine->scheduler = srn_sched_init(engine);
  engine->reactor   = srn_reactor_init(engine);
 
#ifdef SRN_WITH_SERENE
  // Both registries outlive every user context, so they are pinned to a
  // context the engine itself owns. Every trie node an insert creates lands
  // in this context's block chain, which is released only at engine
  // shutdown.
  engine->root_context = srn_context_make(engine);
  engine->namespaces   = hmap_empty(engine->root_context);
  srn_spinlock_init(&engine->ns_lock);
  engine->keywords = hmap_empty(engine->root_context);
  srn_spinlock_init(&engine->keywords_lock);
#endif
  atomic_init(&engine->object_id_counter, ENGINE_FIRST_OBJECT_ID);
 
  return engine;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_engine_shutdown()

void srn_engine_shutdown

(

srn_engine_t *

engine

)

Definition at line 154 of file engine.c.

                                               {
  PANIC_IF_NULL(engine);
 
  srn_reactor_shutdown(engine->reactor);
  srn_sched_shutdown(engine->scheduler);
 
#ifdef SRN_WITH_SERENE
  srn_jit_shutdown(engine->jit);
  srn_context_release(engine->root_context);
#endif
}

Here is the call graph for this function:

srn_generate_seed()

srn_seed_t srn_generate_seed ( )

inlinestatic

Definition at line 65 of file engine.c.

                                             {
  // A genuinely random zero is legal output from every source below, so a
  // zero is retried rather than treated as a failure. Two zeros in a row
  // from a working source is a 2^-64 event, so a tiny bound suffices.
  for (int attempt = 0; attempt < 8; attempt++) {
    srn_seed_t s = 0;
 
#if defined(__linux__)
    auto res = getrandom(&s, sizeof(s), 0);
    if (res < 0) {
      PANIC("Can't get a random number");
    }
#elif defined(__APPLE__)
    arc4random_buf(&s, sizeof(s));
#elif defined(_WIN32)
    NTSTATUS st = BCryptGenRandom(nullptr, (PUCHAR)&s, sizeof(s), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
    if (st != 0) {
      PANIC("Couldn't allocate a seed");
    }
#else
    // fallback: /dev/urandom
    FILE *f = fopen("/dev/urandom", "rb");
    PANIC_IF_NULL(f);
    size_t got = fread(&s, sizeof(s), 1, f);
    UNUSED(fclose(f));
    PANIC_IF(got != 1, "Couldn't read a seed from /dev/urandom");
#endif
 
    if (s != 0) {
      return s;
    }
  }
 
  PANIC("Couldn't generate a nonzero seed");
}

Here is the caller graph for this function:

srn_hash()

srn_hash_t srn_hash	(	const srn_engine_t *	engine,
		const void *	data,
		size_t	len )

Definition at line 166 of file engine.c.

                                                                              {
  // NULL pointers are only valid if the length is zero
  size_t length = (data == nullptr) ? 0 : len;
  return XXH32(data, length, engine->seed);
}

Here is the caller graph for this function: