namespaces.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/namespaces.h"
 
#include "serene/rt/context.h"
#include "serene/rt/core.h"
#include "serene/rt/engine.h"
#include "serene/rt/errors.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/strings.h"
#include "serene/rt/symbols.h"
#include "serene/utils.h"
 
srn_namespace_t *
srn_namespace_get_or_create(srn_engine_t *engine, srn_string_t *name, srn_error_t **err) {
  PANIC_IF_NULL(engine);
  PANIC_IF_NULL(name);
  // TODO(lxsameer): Return these panics as errors. This is fine for now!
  UNUSED(err);
  PANIC_IF(srn_string_is_empty(name), "Empty namespace name is not allowed");
  PANIC_IF(
    srn_string_length(name) > engine->config.limits.ns_name_max_len,
    "Namespace name exceeds the length limit"
  );
  srn_context_t *parent_ctx = engine->root_context;
 
  // 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 *)name->buffer, .len = srn_string_length(name)};
 
  // Readers never take `ns_lock`. Every published head is immutable, so an
  // acquire load is enough to see a fully built map.
  auto namespaces = atomic_load_explicit(&engine->namespaces, memory_order_acquire);
  auto ns_ptr     = srn_context_find_namespace(parent_ctx, (const char *)name->buffer);
 
  if (ns_ptr != nullptr) {
    // A namespace with the same name is already registered.
    return (srn_namespace_t *)ns_ptr;
  }
 
  srn_namespace_t *ns = nullptr;
 
  // Writers are serialized by `ns_lock`. Creating and publishing the
  // namespace both happen while it is held.
  WITH_LOCK(engine->ns_lock, {
    // Another fiber may have registered the same name between the unlocked
    // lookup and taking the lock, so the lookup is repeated here.
    namespaces = atomic_load_explicit(&engine->namespaces, memory_order_relaxed);
    ns         = hmap_lookup(namespaces, &k, nullptr);
 
    if (ns == nullptr) {
      ns               = ALLOC_OR_PANIC(parent_ctx, srn_namespace_t);
      ns->name         = srn_string_copy(parent_ctx, name);
      ns->id           = srn_allocate_object_id(engine);
      ns->root_context = srn_context_make(engine);
 
      // The symbol table outlives the creating context, so it is pinned to the
      // namespace's own root context; the table's keys and trie nodes land in
      // that chain rather than in the creating caller's block. The namespace
      // is not visible to anyone yet, so the atomic is initialized rather
      // than stored.
      hmap_t *sym_table = ALLOC_OR_PANIC(ns->root_context, hmap_t);
      *sym_table        = hmap_empty(ns->root_context);
      atomic_init(&ns->sym_table, sym_table);
      // No node to begin with
      ns->node = nullptr;
 
      ns->sym_table_lock = ALLOC_OR_PANIC(ns->root_context, srn_fiber_mutex_t);
      srn_fiber_mutex_init(ns->sym_table_lock);
 
      // Every head is immutable once published, so the new version gets its
      // own allocation and the old one stays valid for readers that already
      // loaded it.
      hmap_t *next = ALLOC_OR_PANIC(parent_ctx, hmap_t);
      *next        = hmap_insert(namespaces, &k, ns);
 
      atomic_store_explicit(&engine->namespaces, next, memory_order_release);
    }
  });
 
  return ns;
}
 
srn_namespace_t *srn_namespace_load(srn_namespace_t *ns) {
  PANIC_IF_NULL(ns);
  return nullptr;
}