engine.h File Reference

#include <stdatomic.h>
#include <stddef.h>
#include <stdint.h>
#include "serene/rt/configuration.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/utils.h"

Include dependency graph for engine.h:

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

Go to the source code of this file.

Data Structures
struct	srn_engine_t
	Engine is a structure to own the long living and main pieces of the compiler. More...

Macros
#define	SRN_HASH_TYPE   uint32_t
#define	SRN_SEED_TYPE   uint32_t
#define	ENGINE_FIRST_OBJECT_ID   100
	Start allocating IDs from 100, earlier IDs are reserved.

Typedefs
typedef struct srn_scheduler_t	srn_scheduler_t
typedef struct srn_reactor_t	srn_reactor_t
	The implementation is internal to the runtime.
typedef struct srn_sm_t	srn_sm_t
typedef uint64_t	srn_object_id_t
typedef struct srn_engine_t	srn_engine_t
	Engine is a structure to own the long living and main pieces of the compiler.

Functions
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_object_id_t	srn_allocate_object_id (srn_engine_t *engine)
srn_hash_t	srn_hash (const srn_engine_t *engine, const void *data, size_t len)

Macro Definition Documentation

ENGINE_FIRST_OBJECT_ID

#define ENGINE_FIRST_OBJECT_ID   100

Start allocating IDs from 100, earlier IDs are reserved.

Definition at line 47 of file engine.h.

SRN_HASH_TYPE

#define SRN_HASH_TYPE   uint32_t

Definition at line 29 of file engine.h.

SRN_SEED_TYPE

#define SRN_SEED_TYPE   uint32_t

Definition at line 30 of file engine.h.

Typedef Documentation

srn_engine_t

typedef struct srn_engine_t srn_engine_t

Engine is a structure to own the long living and main pieces of the compiler.

There will be only oe instance of the engine at anytime.

srn_object_id_t

typedef uint64_t srn_object_id_t

Definition at line 45 of file engine.h.

srn_reactor_t

typedef struct srn_reactor_t srn_reactor_t

The implementation is internal to the runtime.

Definition at line 41 of file engine.h.

srn_scheduler_t

typedef struct srn_scheduler_t srn_scheduler_t

Definition at line 40 of file engine.h.

srn_sm_t

typedef struct srn_sm_t srn_sm_t

Definition at line 42 of file engine.h.

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_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: