engine.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * 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/impl/hashmap.h"
#include "serene/rt/mm/interface.h"
#include "serene/rt/reactor.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_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;
}
 
void srn_engine_shutdown(srn_engine_t *engine) {
  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
}
 
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);
 
  srn_spinlock_lock(&engine->keywords_lock);
 
  // Fast path, return any existing entry under the same name.
  hmap_key_t lookup = {.data = (void *)name, .len = name_len};
  void *found       = hmap_lookup(&engine->keywords, &lookup, nullptr);
  if (found != nullptr) {
    srn_spinlock_unlock(&engine->keywords_lock);
    return (srn_value_t *)found;
  }
 
  if (name_len == max_len) {
    srn_spinlock_unlock(&engine->keywords_lock);
    return srn_errors_make_error(
      ctx, metadata, STRING_LENGTH_LIMIT_EXCEEDED, "Keyword name exceeds the string length limit"
    );
  }
 
  // 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.
  srn_value_t *v = srn_mm_immortal_allocate(mm, srn_value_t);
  v->type        = VKeyword;
  v->metadata    = metadata;
  v->as.keyword  = kw;
 
  hmap_key_t k     = {.data = (void *)name_str->buffer, .len = name_str->len};
  engine->keywords = hmap_insert(&engine->keywords, &k, (void *)v);
 
  srn_spinlock_unlock(&engine->keywords_lock);
  return v;
}
#endif