engine.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#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"
 
#ifdef SRN_WITH_SERENE
#  include "serene/jit/jit.h"
#  include "serene/rt/core.h"
#  include "serene/rt/errors.h"
#  include "serene/rt/keywords.h"
#  include "serene/rt/strings.h"
#endif
 
#include <assert.h>
#include <signal.h>
#include <string.h>
 
#define XXH_INLINE_ALL
#define XXH_STATIC_LINKING_ONLY
#define XXH_ENABLE_AUTOVECTORIZE
// Disable invocation of <stdlib.h> functions, notably malloc() and free()
#define XXH_NO_STDLIB
// We use xxhash 32bit only, so no need for these
#define XXH_NO_XXH3
#define XXH_NO_LONG_LONG
#define XXH_NO_STREAM
#define XXH_IMPLEMENTATION
#include "third_party/xxhash.h"
 
#if defined(__linux__) || defined(__GLIBC__)
#  include <sys/random.h>
#elif defined(__APPLE__)
#  include <stdlib.h>
#elif defined(_WIN32)
#  define NOMINMAX
#  include <bcrypt.h>
#  include <windows.h>
#  pragma comment(lib, "bcrypt.lib")
#endif
 
// Allocate a random Seed. This function has to be run every
// time we allocate a new context
static inline srn_seed_t srn_generate_seed() {
  // 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");
}
 
srn_engine_t *srn_engine_make(srn_mm_t *mm, const srn_configuration_t *config) {
  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;
}
 
void srn_engine_shutdown(srn_engine_t *engine) {
  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
}
 
srn_hash_t srn_hash(const srn_engine_t *engine, const void *data, size_t len) {
  // NULL pointers are only valid if the length is zero
  size_t length = (data == nullptr) ? 0 : len;
  return XXH32(data, length, engine->seed);
}
 
srn_object_id_t srn_allocate_object_id(srn_engine_t *engine) {
  PANIC_IF_NULL(engine);
  return atomic_fetch_add_explicit(&engine->object_id_counter, 1, memory_order_relaxed);
}
 
/* #ifdef SRN_WITH_SERENE */
/* srn_value_t * */
/* srn_engine_intern_keyword(srn_context_t *ctx, srn_metadata_t *metadata, const char *name) { */
/*   PANIC_IF_NULL(ctx); */
/*   PANIC_IF_NULL(name); */
 
/*   srn_engine_t *engine = ctx->engine; */
/*   srn_mm_t *mm         = engine->mm; */
/*   // Cap the read at the configured string-length limit so a malformed */
/*   // unbounded `name` does not produce an oversized allocation. */
/*   const size_t max_len = engine->config.limits.string_max_len; */
/*   size_t name_len      = strnlen(name, max_len); */
 
/*   // A read that hit the cap was truncated, so it must not reach the table. */
/*   // Its prefix could otherwise match a shorter keyword and hand back the wrong */
/*   // value. */
/*   if (name_len == max_len) { */
/*     return srn_errors_make_error( */
/*       ctx, metadata, STRING_LENGTH_LIMIT_EXCEEDED, "Keyword name exceeds the string length limit"
 */
/*     ); */
/*   } */
 
/*   hmap_key_t k = {.data = (void *)name, .len = name_len}; */
 
/*   // Every published head is immutable, so readers only need an acquire load */
/*   // and never take the lock. */
/*   hmap_t *keywords = atomic_load_explicit(&engine->keywords, memory_order_acquire); */
/*   void *found      = hmap_lookup(keywords, &k, nullptr); */
/*   if (found != nullptr) { */
/*     return (srn_value_t *)found; */
/*   } */
 
/*   srn_value_t *v = nullptr; */
 
/*   // Writers are serialized by `keywords_lock`. Two interners racing on the */
/*   // same new name would otherwise both miss and produce two distinct */
/*   // keywords, and keyword equality is pointer identity. */
/*   WITH_LOCK(engine->keywords_lock, { */
/*     // Another interner may have added the name between the unlocked lookup */
/*     // and taking the lock, so the lookup is repeated here. */
/*     keywords = atomic_load_explicit(&engine->keywords, memory_order_relaxed); */
/*     v        = hmap_lookup(keywords, &k, nullptr); */
 
/*     if (v == nullptr) { */
/*       // Interned keywords must outlive any individual context, so the name */
/*       // buffer, the keyword payload, and the value wrapper live in the */
/*       // engine's immortal memory. The table key and the trie nodes are */
/*       // handled by the map itself, which copies and allocates them in its */
/*       // pinned context. */
 
/*       // Name string. */
/*       size_t name_alloc_size = sizeof(srn_string_t) + name_len + 1; */
/*       srn_string_t *name_str = */
/*         srn_mm_immortal_allocate_aligned(mm, name_alloc_size, alignof(srn_string_t)); */
/*       name_str->len  = name_len; */
/*       name_str->size = name_len + 1; */
/*       memcpy(name_str->buffer, name, name_len); */
/*       name_str->buffer[name_len] = '\0'; */
 
/*       // Keyword payload. */
/*       srn_keyword_t *kw = srn_mm_immortal_allocate(mm, srn_keyword_t); */
/*       kw->name          = name_str; */
 
/*       // Value wrapper. */
/*       v             = srn_mm_immortal_allocate(mm, srn_value_t); */
/*       v->type       = VKeyword; */
/*       v->metadata   = metadata; */
/*       v->as.keyword = kw; */
 
/*       // The old head stays valid for readers that already loaded it, so the */
/*       // new version gets its own allocation. */
/*       hmap_t *next = ALLOC_OR_PANIC(engine->root_context, hmap_t); */
/*       *next        = hmap_insert(keywords, &k, (void *)v); */
/*       atomic_store_explicit(&engine->keywords, next, memory_order_release); */
/*     } */
/*   }); */
 
/*   return v; */
/* } */
/* #endif */