context.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/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_allocate_or_panic(const srn_context_t *ctx, size_t size, size_t alignment) {
  auto x = srn_allocate(ctx, size, alignment);
  PANIC_IF_NULL(x);
  return x;
}
 
void srn_release(const srn_context_t *ctx, void *ptr) {
  // No Op.
  // This is just for future proofing
}
 
#ifdef SRN_WITH_SERENE
srn_namespace_t *srn_context_find_namespace(srn_context_t *ctx, const char *name) {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(name);
  auto max_len = ctx->engine->config.limits.ns_name_max_len;
  // The key must cover the same bytes `srn_namespace_get_or_create` inserted
  // under, the name without its null terminator.
  hmap_key_t k = {.data = (void *)name, .len = strnlen(name, max_len)};
  // Every published head is immutable, so an acquire load of the pointer is
  // all a reader needs. No lock is taken.
  hmap_t *namespaces = atomic_load_explicit(&ctx->engine->namespaces, memory_order_acquire);
  return (srn_namespace_t *)hmap_lookup(namespaces, &k, nullptr);
}
#endif