engine.c File Reference

#include "serene/rt/engine.h"
#include "serene/rt/context.h"
#include "serene/rt/fiber.h"
#include "serene/rt/fiber/mutex.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/mm/interface.h"
#include "serene/rt/reactor.h"
#include "serene/rt/source_manager.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 44 of file engine.c.

XXH_IMPLEMENTATION

#define XXH_IMPLEMENTATION

Definition at line 51 of file engine.c.

XXH_INLINE_ALL

#define XXH_INLINE_ALL

Definition at line 42 of file engine.c.

XXH_NO_LONG_LONG

#define XXH_NO_LONG_LONG

Definition at line 49 of file engine.c.

XXH_NO_STDLIB

#define XXH_NO_STDLIB

Definition at line 46 of file engine.c.

XXH_NO_STREAM

#define XXH_NO_STREAM

Definition at line 50 of file engine.c.

XXH_NO_XXH3

#define XXH_NO_XXH3

Definition at line 48 of file engine.c.

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

Definition at line 43 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 193 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 103 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_create(mm, nullptr);
  // PANIC_IF_NULL(engine->jit);
#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);
 
  // Each registry head is an immutable, heap allocated map that readers load
  // atomically without a lock. Writers replace the head under the matching
  // mutex, so the mutexes live in the same context as the heads. Nothing
  // else can see the engine yet, so the atomics are initialized instead of stored.
  hmap_t *namespaces = ALLOC_OR_PANIC(engine->root_context, hmap_t);
  *namespaces        = hmap_empty(engine->root_context);
  atomic_init(&engine->namespaces, namespaces);
 
  engine->ns_lock = ALLOC_OR_PANIC(engine->root_context, srn_fiber_mutex_t);
  srn_fiber_mutex_init(engine->ns_lock);
 
  hmap_t *keywords = ALLOC_OR_PANIC(engine->root_context, hmap_t);
  *keywords        = hmap_empty(engine->root_context);
  atomic_init(&engine->keywords, keywords);
 
  engine->keywords_lock = ALLOC_OR_PANIC(engine->root_context, srn_fiber_mutex_t);
  srn_fiber_mutex_init(engine->keywords_lock);
#endif
  atomic_init(&engine->object_id_counter, ENGINE_FIRST_OBJECT_ID);
 
  // TODO(lxsameer): Should we create a sub context out of root?
  engine->source_manager = srn_sm_init(engine->root_context);
 
  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 174 of file engine.c.

                                               {
  PANIC_IF_NULL(engine);
 
  srn_reactor_shutdown(engine->reactor);
  srn_sched_shutdown(engine->scheduler);
  srn_sm_shutdown(engine->source_manager);
 
#ifdef SRN_WITH_SERENE
  // srn_jit_destroy(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 67 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 187 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 call graph for this function:

Here is the caller graph for this function: