symbols.h File Reference

#include "serene/rt/core.h"
#include "serene/rt/engine.h"

Include dependency graph for symbols.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	srn_symbol_t

Typedefs
typedef struct srn_symbol_t	srn_symbol_t

Functions
srn_value_t *	srn_symbol_make (srn_context_t *ctx, srn_metadata_t *metadata, srn_namespace_t *ns, srn_string_t *name)
	Create a new symbol. IT DOES NOT INTERNALIZE THE SYMBOL.
srn_value_t *	srn_symbol_intern (srn_context_t *ctx, srn_metadata_t *metadata, srn_namespace_t *ns, srn_string_t *symbol_name)
srn_value_t *	srn_symbol_gen (srn_context_t *ctx, srn_metadata_t *metadata, srn_namespace_t *ns, srn_string_t *optional_name)

Typedef Documentation

srn_symbol_t

typedef struct srn_symbol_t srn_symbol_t

Function Documentation

srn_symbol_gen()

srn_value_t * srn_symbol_gen	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_namespace_t *	ns,
		srn_string_t *	optional_name )

Definition at line 94 of file symbols.c.

  {
  // TODO(lxsameer): Fold the optional name into the generated spelling.
  UNUSED(optional_name);
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(ns);
 
  // A generated symbol must be fresh, a symbol nothing else already names.
  // The spelling is readable text, so a user symbol can occupy it. When the
  // name is taken, a new id gives a new name to try. The lock covers the
  // lookup and the insert, the pairing srn_symbol_intern relies on too.
  for (;;) {
    srn_object_id_t id = srn_allocate_object_id(ctx->engine);
 
    // Calculate the length
    int len = snprintf(nullptr, 0, "gensym_%" PRIu64, id);
    PANIC_IF(len < 0, "This should never happen!");
 
    // Including the null terminator
    char *name = srn_allocate(ctx, len + 1, alignof(char));
    (void)snprintf(name, len + 1, "gensym_%" PRIu64, id);
 
    srn_value_t *sym_name = srn_string_make(ctx, metadata, name);
    hmap_key_t k = {.data = &AS_STRING(sym_name)->buffer, .len = AS_STRING(sym_name)->size};
 
    srn_value_t *sym = nullptr;
 
    WITH_LOCK(ns->sym_table_lock, {
      hmap_t *table = atomic_load_explicit(&ns->sym_table, memory_order_relaxed);
 
      if (hmap_lookup(table, &k, nullptr) == nullptr) {
        // The table retains the symbol for the namespace's lifetime, so the
        // value and its name copy are allocated through the namespace's root
        // context, not the generating caller's transient one.
        sym = srn_symbol_make(ns->root_context, metadata, ns, AS_STRING(sym_name));
 
        hmap_t *next = ALLOC_OR_PANIC(ns->root_context, hmap_t);
        *next        = hmap_insert(table, &k, (void *)sym);
        atomic_store_explicit(&ns->sym_table, next, memory_order_release);
      }
    });
 
    // A null `sym` means the spelling was taken, so the loop tries the next id.
    if (sym != nullptr) {
      return sym;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_symbol_intern()

srn_value_t * srn_symbol_intern	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_namespace_t *	ns,
		srn_string_t *	symbol_name )

Definition at line 45 of file symbols.c.

  {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(ns);
  PANIC_IF_NULL(symbol_name);
 
  if (srn_string_is_empty(symbol_name)) {
    return srn_errors_make_error(ctx, metadata, EMPTY_SYMBOL_NAME, nullptr);
  };
 
  hmap_key_t k = {.data = &symbol_name->buffer, .len = symbol_name->size};
 
  // Every published table head is immutable, so readers only need an acquire
  // load and never take the lock.
  hmap_t *table = atomic_load_explicit(&ns->sym_table, memory_order_acquire);
  void *result  = hmap_lookup(table, &k, nullptr);
  if (result != nullptr) {
    return (srn_value_t *)result;
  }
 
  srn_value_t *sym = nullptr;
 
  // The lock covers the lookup as well as the insert. Two interners racing
  // on the same new name would otherwise both miss and insert two distinct
  // symbols for one name, and symbol equality is pointer identity.
  WITH_LOCK(ns->sym_table_lock, {
    // Another interner may have added the name between the unlocked lookup
    // and taking the lock, so the lookup is repeated here.
    table = atomic_load_explicit(&ns->sym_table, memory_order_relaxed);
    sym   = hmap_lookup(table, &k, nullptr);
 
    if (sym == nullptr) {
      // The table retains the symbol for the namespace's lifetime, so the
      // value and its name copy are allocated through the namespace's root
      // context, not the interning caller's transient one.
      sym = srn_symbol_make(ns->root_context, metadata, ns, symbol_name);
 
      // The old head stays valid for readers that already loaded it, so the
      // new version gets its own allocation.
      hmap_t *next = ALLOC_OR_PANIC(ns->root_context, hmap_t);
      *next        = hmap_insert(table, &k, (void *)sym);
      atomic_store_explicit(&ns->sym_table, next, memory_order_release);
    }
  });
 
  return sym;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_symbol_make()

srn_value_t * srn_symbol_make	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_namespace_t *	ns,
		srn_string_t *	name )

Create a new symbol. IT DOES NOT INTERNALIZE THE SYMBOL.

Definition at line 30 of file symbols.c.

  {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(ns);
  PANIC_IF_NULL(name);
 
  srn_symbol_t *sym = ALLOC(ctx, srn_symbol_t);
  sym->name         = srn_string_copy(ctx, name);
 
  sym->ns = ns;
 
  return srn_value_make(ctx, VSymbol, metadata, (void *)sym);
}

Here is the call graph for this function:

Here is the caller graph for this function: