context.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/context.h"
 
#include "serene/rt/engine.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/mm/interface.h"
#include "serene/utils.h"
 
#ifdef SRN_WITH_SERENE
#  include <string.h>
 
#  include "serene/rt/namespaces.h"
#  include "serene/rt/strings.h"
#endif
 
#if defined(CTX_DEBUG)
#  define CTX_LOG(FMT, ...) DBG("CTX", FMT __VA_OPT__(, ) __VA_ARGS__)
#else
#  define CTX_LOG(FMT, ...)
#endif
 
srn_context_t *srn_context_make(srn_engine_t *engine) {
  PANIC_IF_NULL(engine);
  srn_block_id_t block_id = srn_mm_allocate_block(engine->mm);
  srn_context_t *ctx      = srn_mm_allocate_in_block(engine->mm, block_id, srn_context_t);
  PANIC_IF_NULL(ctx);
  ctx->parent   = nullptr;
  ctx->engine   = engine;
  ctx->block_id = block_id;
  return ctx;
}
 
/* srn_context_t *srn_context_make_subcontext(srn_context_t *parent, */
/*                                            srn_block_id_t block_id) { */
/*   PANIC_IF_NULL(parent); */
/*   srn_context_t *ctx = */
/*       srn_mm_allocate_in_block(parent->engine->mm, block_id, srn_context_t);
 */
/*   PANIC_IF_NULL(ctx); */
/*   ctx->parent   = parent; */
/*   ctx->engine   = parent->engine; */
/*   ctx->block_id = parent->block_id; */
 
/*   return ctx; */
/* } */
 
int srn_context_release(srn_context_t *ctx) {
  PANIC_IF_NULL(ctx);
  if (ctx->block_id != SRN_BLOCK_NO_ID) {
    CTX_LOG("Releasing block: %zu", ctx->block_id);
    srn_mm_release_block(ctx->engine->mm, ctx->block_id);
  }
  return 0;
}
 
void *srn_allocate(const srn_context_t *ctx, size_t size, size_t alignment) {
  PANIC_IF_NULL(ctx);
  return srn_mm_allocate_in_block_aligned(ctx->engine->mm, ctx->block_id, size, alignment);
}
 
void srn_release(const srn_context_t *ctx, void *ptr) {
  // No Op.
  // This is just for future proofing
}
 
#ifdef SRN_WITH_SERENE
srn_error_t *srn_context_register_namespace(srn_context_t *ctx, srn_namespace_t *ns) {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(ns);
 
  srn_spinlock_lock(&ctx->engine->ns_lock);
  // The key is the raw bytes of the namespace name (no struct header,
  // no null terminator). The map copies the key into its pinned context, so
  // a stack struct is enough here. Find by C string must use the same byte
  // range as the key.
  hmap_key_t k = {.data = (void *)ns->name->buffer, .len = srn_string_length(ns->name)};
  // The new hmap_t shares structure with the previous version through the
  // persistent CHAMT representation, so assigning the result back into the
  // engine slot is a constant-time pointer/length update.
  ctx->engine->namespaces = hmap_insert(&ctx->engine->namespaces, &k, (void *)ns);
  srn_spinlock_unlock(&ctx->engine->ns_lock);
  return nullptr;
}
 
srn_namespace_t *srn_context_find_namespace(srn_context_t *ctx, const char *name) {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(name);
  hmap_key_t k = {.data = (void *)name, .len = strlen(name)};
  // Snapshot the map struct under the lock, registration replaces it in the
  // engine slot and an unsynchronized reader could see a torn root and
  // length pair. CHAMT nodes are immutable and arena backed, so the walk
  // itself is safe outside the critical region.
  srn_spinlock_lock(&ctx->engine->ns_lock);
  hmap_t namespaces = ctx->engine->namespaces;
  srn_spinlock_unlock(&ctx->engine->ns_lock);
  return (srn_namespace_t *)hmap_lookup(&namespaces, &k, nullptr);
}
#endif