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/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 <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() {
  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");
  fread(&s, sizeof(s), 1, f);
  fclose(f);
#endif
 
  // Avoiding zero seed
  if (s == 0) {
    PANIC("Couldn't allocate a seed");
  }
  return s;
}
 
srn_engine_t *srn_engine_make(srn_mm_t *mm) {
  PANIC_IF_NULL(mm);
  srn_engine_t *engine = srn_mm_immortal_allocate(mm, srn_engine_t);
 
  if (engine == nullptr) {
    return nullptr;
  }
 
  engine->seed = srn_generate_seed();
  // Just reserving 0..100 for any unpredicted needs
  engine->mm = mm;
 
#ifdef SRN_WITH_SERENE
  engine->jit = srn_jit_make(mm);
#endif
  engine->scheduler = srn_sched_init(engine);
 
#ifdef SRN_WITH_SERENE
  // Both registries start empty. An empty hmap_t is just {.len = 0,
  // .root = nullptr} and matches what hmap_empty would return, so we can
  // initialize them inline without needing a context here.
  engine->namespaces = (hmap_t){.len = 0, .root = nullptr};
  srn_spinlock_init(&engine->ns_lock);
  engine->keywords = (hmap_t){.len = 0, .root = nullptr};
  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_sched_shutdown(engine->scheduler);
#ifdef SRN_WITH_SERENE
  srn_jit_shutdown(engine->jit);
#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 documented string-length limit so a malformed
  // unbounded `name` does not produce an oversized allocation.
  size_t name_len = strnlen(name, SRN_STRING_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(ctx, &engine->keywords, &lookup, nullptr);
  if (found != nullptr) {
    srn_spinlock_unlock(&engine->keywords_lock);
    return (srn_value_t *)found;
  }
 
  if (name_len == SRN_STRING_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 every piece of
  // the value lives in the engine's immortal memory: the name buffer, the
  // keyword payload, the value wrapper, and the hmap key that references the
  // name buffer.
 
  // 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;
 
  // The hmap_key_t holds a pointer to the key bytes, not a copy of them.
  // Both the key struct and its bytes must outlive any context, so allocate
  // the key struct immortally and point it at the interned name buffer.
  hmap_key_t *k = srn_mm_immortal_allocate(mm, hmap_key_t);
  k->data = (void *)name_str->buffer;
  k->len = name_str->len;
  engine->keywords = hmap_insert(ctx, &engine->keywords, k, (void *)v);
 
  srn_spinlock_unlock(&engine->keywords_lock);
  return v;
}
#endif