/*
  StarForth — Steady-State Virtual Machine Runtime

  Copyright (c) 2023–2025 Robert A. James
  All rights reserved.

  This file is part of the StarForth project.

  Licensed under the StarForth License, Version 1.0 (the "License");
  you may not use this file except in compliance with the License.

  You may obtain a copy of the License at:
      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt

  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
  express or implied, including but not limited to the warranties of
  merchantability, fitness for a particular purpose, and noninfringement.

 See the License for the specific language governing permissions and
 limitations under the License.

 StarForth — Steady-State Virtual Machine Runtime
  Copyright (c) 2023–2025 Robert A. James
  All rights reserved.

  This file is part of the StarForth project.

  Licensed under the StarForth License, Version 1.0 (the "License");
  you may not use this file except in compliance with the License.

  You may obtain a copy of the License at:
       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt

  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
  express or implied, including but not limited to the warranties of
  merchantability, fitness for a particular purpose, and noninfringement.

  See the License for the specific language governing permissions and
  limitations under the License.

 */

/*
                                  ***   StarForth   ***

  dictionary_heat_optimization.h - Phase 2: Heat-Aware Dictionary Lookup

  Inference-driven optimizations for dictionary lookup based on execution heat
  patterns from the Rolling Window of Truth:

  1. Heat percentile thresholds (25th, 50th, 75th)
  2. Bucket reorganization by co-execution patterns
  3. Heat-aware lookup strategy (search hot words first)
*/

#ifndef DICTIONARY_HEAT_OPTIMIZATION_H
#define DICTIONARY_HEAT_OPTIMIZATION_H

#include "vm.h"

/**
 * @brief Calculate heat percentile thresholds for all words in dictionary
 *
 * Computes 25th, 50th, 75th percentiles of execution_heat across all
 * dictionary entries. Used to partition lookup search order.
 */
void dict_update_heat_percentiles(VM *vm);

/**
 * @brief Reorganize dictionary buckets by inference-driven priorities
 *
 * Uses rolling window co-execution patterns to reorder words within buckets.
 * Hot/frequently co-executing words are placed first for faster lookup.
 */
void dict_reorganize_buckets_by_heat(VM *vm);

/**
 * @brief Find word with heat-aware search strategy
 *
 * Instead of newest-first, searches buckets in order:
 * 1. Top 25% by heat (likely hits)
 * 2. Middle 50% by heat
 * 3. Bottom 25% (rarely executed)
 */
DictEntry *dict_find_word_heat_aware(VM *vm, const char *name, size_t len);

/**
 * @brief Periodically reoptimize dictionary based on latest heat patterns
 *
 * Called every ~1 second or every N executions to adapt lookup strategy
 * to current workload patterns from rolling window.
 */
void dict_adaptive_optimization_pass(VM *vm);

/* First-character (fc) lookup index — shared between dictionary_management.c
   and dictionary_heat_optimization.c.  Declared here once to give LTO a single
   canonical type definition and avoid -Werror=lto-type-mismatch.

   FABRIC-3.10.8 Stage MC-0c: one index per VM (vm->fc_index), not one for
   the whole system. The old global index held whichever VM's dictionary was
   searched last, so alternating between two VMs rebuilt it on every switch,
   and a heat reorganization could reorder another VM's buckets. SF_FC_BUCKETS
   is one bucket per possible first byte, the whole domain, not a capacity. */
#ifndef SF_FC_BUCKETS
#define SF_FC_BUCKETS 256
#endif
struct SfFcIndex {
    DictEntry **list[SF_FC_BUCKETS];  /* per bucket: entries, [0]=oldest */
    size_t      count[SF_FC_BUCKETS];
    size_t      cap[SF_FC_BUCKETS];
    DictEntry  *cached_latest;        /* the vm->latest this index reflects */
    uint64_t    rebuilds;             /* full rebuilds of this index, ever */
};

/* This VM's index, allocated on first use; NULL only if that allocation
   failed (counted and logged -- lookups then walk the dictionary). */
struct SfFcIndex *vm_dictionary_index(VM *vm);

/* Frees vm's index (vm_cleanup()). */
void vm_dictionary_index_free(VM *vm);

/* Index allocations refused for lack of memory, system-wide. */
uint32_t vm_dictionary_index_alloc_failures(void);

#endif /* DICTIONARY_HEAT_OPTIMIZATION_H */