tomoaki/hakmem
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

release: silence runtime logs and stabilize benches

Browse Source 
- Fix HAKMEM_LOG gating to use  (numeric) so release builds compile out logs.
- Switch remaining prints to HAKMEM_LOG or guard with :
  - core/box/hak_core_init.inc.h (EVO sample warning, shutdown banner)
  - core/hakmem_config.c (config/feature prints)
  - core/hakmem.c (BigCache eviction prints)
  - core/hakmem_tiny_superslab.c (OOM, head init/expand, C7 init diagnostics)
  - core/hakmem_elo.c (init/evolution)
  - core/hakmem_batch.c (init/flush/stats)
  - core/hakmem_ace.c (33KB route diagnostics)
  - core/hakmem_ace_controller.c (ACE logs macro → no-op in release)
  - core/hakmem_site_rules.c (init banner)
  - core/box/hak_free_api.inc.h (unknown method error → release-gated)
- Rebuilt benches and verified quiet output for release:
  - bench_fixed_size_hakmem/system
  - bench_random_mixed_hakmem/system
  - bench_mid_large_mt_hakmem/system
  - bench_comprehensive_hakmem/system

Note: Kept debug logs available in debug builds and when explicitly toggled via env.
This commit is contained in:
Moe Charm (CI)
2025-11-11 01:47:06 +09:00
parent a97005f50e
commit 8feeb63c2b
25 changed files with 215 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
core/hakmem_config.c
View File

@ -4,6 +4,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "hakmem_internal.h" // HAKMEM_LOG for release-silent logging
// ===========================================================================
// Global Configuration Instance
@ -158,7 +159,7 @@ void hak_config_apply_mode(HakemMode mode) {
case HAKMEM_MODE_LEARNING: apply_learning_mode(&g_hakem_config); break;
case HAKMEM_MODE_RESEARCH: apply_research_mode(&g_hakem_config); break;
default:
fprintf(stderr, "[hakmem] Unknown mode %d, using BALANCED\n", mode);
HAKMEM_LOG("Unknown mode %d, using BALANCED\n", mode);
apply_balanced_mode(&g_hakem_config);
break;
}
@ -177,7 +178,7 @@ static HakemMode parse_mode_env(const char* mode_str) {
if (strcmp(mode_str, "learning") == 0) return HAKMEM_MODE_LEARNING;
if (strcmp(mode_str, "research") == 0) return HAKMEM_MODE_RESEARCH;
fprintf(stderr, "[hakmem] Unknown HAKMEM_MODE='%s', using balanced\n", mode_str);
HAKMEM_LOG("Unknown HAKMEM_MODE='%s', using balanced\n", mode_str);
return HAKMEM_MODE_BALANCED;
}
@ -247,58 +248,58 @@ void hak_config_init(void) {
// ===========================================================================
void hak_config_print(void) {
fprintf(stderr, "\n========================================\n");
fprintf(stderr, "hakmem Configuration\n");
fprintf(stderr, "========================================\n");
fprintf(stderr, "Mode: %s\n", g_hakem_config.mode_name);
fprintf(stderr, "\n");
HAKMEM_LOG("\n========================================\n");
HAKMEM_LOG("hakmem Configuration\n");
HAKMEM_LOG("========================================\n");
HAKMEM_LOG("Mode: %s\n", g_hakem_config.mode_name);
HAKMEM_LOG("\n");
fprintf(stderr, "Features:\n");
fprintf(stderr, " Allocation:\n");
fprintf(stderr, " malloc: %s\n", (g_hakem_config.features.alloc & HAKMEM_FEATURE_MALLOC) ? "ON" : "OFF");
fprintf(stderr, " mmap: %s\n", (g_hakem_config.features.alloc & HAKMEM_FEATURE_MMAP) ? "ON" : "OFF");
fprintf(stderr, " pool: %s\n", (g_hakem_config.features.alloc & HAKMEM_FEATURE_POOL) ? "ON" : "OFF");
HAKMEM_LOG("Features:\n");
HAKMEM_LOG(" Allocation:\n");
HAKMEM_LOG(" malloc: %s\n", (g_hakem_config.features.alloc & HAKMEM_FEATURE_MALLOC) ? "ON" : "OFF");
HAKMEM_LOG(" mmap: %s\n", (g_hakem_config.features.alloc & HAKMEM_FEATURE_MMAP) ? "ON" : "OFF");
HAKMEM_LOG(" pool: %s\n", (g_hakem_config.features.alloc & HAKMEM_FEATURE_POOL) ? "ON" : "OFF");
fprintf(stderr, " Caching:\n");
fprintf(stderr, " BigCache: %s\n", (g_hakem_config.features.cache & HAKMEM_FEATURE_BIGCACHE) ? "ON" : "OFF");
fprintf(stderr, " TinyPool: %s\n", (g_hakem_config.features.cache & HAKMEM_FEATURE_TINYPOOL) ? "ON" : "OFF");
HAKMEM_LOG(" Caching:\n");
HAKMEM_LOG(" BigCache: %s\n", (g_hakem_config.features.cache & HAKMEM_FEATURE_BIGCACHE) ? "ON" : "OFF");
HAKMEM_LOG(" TinyPool: %s\n", (g_hakem_config.features.cache & HAKMEM_FEATURE_TINYPOOL) ? "ON" : "OFF");
fprintf(stderr, " Learning:\n");
fprintf(stderr, " ELO: %s\n", (g_hakem_config.features.learning & HAKMEM_FEATURE_ELO) ? "ON" : "OFF");
fprintf(stderr, " Evolution: %s\n", (g_hakem_config.features.learning & HAKMEM_FEATURE_EVOLUTION) ? "ON" : "OFF");
fprintf(stderr, " Profiling: %s\n", (g_hakem_config.features.learning & HAKMEM_FEATURE_PROFILING) ? "ON" : "OFF");
HAKMEM_LOG(" Learning:\n");
HAKMEM_LOG(" ELO: %s\n", (g_hakem_config.features.learning & HAKMEM_FEATURE_ELO) ? "ON" : "OFF");
HAKMEM_LOG(" Evolution: %s\n", (g_hakem_config.features.learning & HAKMEM_FEATURE_EVOLUTION) ? "ON" : "OFF");
HAKMEM_LOG(" Profiling: %s\n", (g_hakem_config.features.learning & HAKMEM_FEATURE_PROFILING) ? "ON" : "OFF");
fprintf(stderr, " Memory:\n");
fprintf(stderr, " Batch madvise: %s\n", (g_hakem_config.features.memory & HAKMEM_FEATURE_BATCH_MADVISE) ? "ON" : "OFF");
fprintf(stderr, " THP: %s\n", (g_hakem_config.features.memory & HAKMEM_FEATURE_THP) ? "ON" : "OFF");
fprintf(stderr, " Free policy: %s\n", (g_hakem_config.features.memory & HAKMEM_FEATURE_FREE_POLICY) ? "ON" : "OFF");
HAKMEM_LOG(" Memory:\n");
HAKMEM_LOG(" Batch madvise: %s\n", (g_hakem_config.features.memory & HAKMEM_FEATURE_BATCH_MADVISE) ? "ON" : "OFF");
HAKMEM_LOG(" THP: %s\n", (g_hakem_config.features.memory & HAKMEM_FEATURE_THP) ? "ON" : "OFF");
HAKMEM_LOG(" Free policy: %s\n", (g_hakem_config.features.memory & HAKMEM_FEATURE_FREE_POLICY) ? "ON" : "OFF");
fprintf(stderr, " Debug:\n");
fprintf(stderr, " Logging: %s\n", (g_hakem_config.features.debug & HAKMEM_FEATURE_DEBUG_LOG) ? "ON" : "OFF");
fprintf(stderr, " Statistics: %s\n", (g_hakem_config.features.debug & HAKMEM_FEATURE_STATISTICS) ? "ON" : "OFF");
fprintf(stderr, " Trace: %s\n", (g_hakem_config.features.debug & HAKMEM_FEATURE_TRACE) ? "ON" : "OFF");
HAKMEM_LOG(" Debug:\n");
HAKMEM_LOG(" Logging: %s\n", (g_hakem_config.features.debug & HAKMEM_FEATURE_DEBUG_LOG) ? "ON" : "OFF");
HAKMEM_LOG(" Statistics: %s\n", (g_hakem_config.features.debug & HAKMEM_FEATURE_STATISTICS) ? "ON" : "OFF");
HAKMEM_LOG(" Trace: %s\n", (g_hakem_config.features.debug & HAKMEM_FEATURE_TRACE) ? "ON" : "OFF");
fprintf(stderr, "\n");
fprintf(stderr, "Policies:\n");
fprintf(stderr, " Free policy: %s\n",
HAKMEM_LOG("\n");
HAKMEM_LOG("Policies:\n");
HAKMEM_LOG(" Free policy: %s\n",
g_hakem_config.free_policy == FREE_POLICY_BATCH ? "batch" :
g_hakem_config.free_policy == FREE_POLICY_KEEP ? "keep" :
g_hakem_config.free_policy == FREE_POLICY_ADAPTIVE ? "adaptive" : "unknown");
fprintf(stderr, " THP policy: %s\n",
HAKMEM_LOG(" THP policy: %s\n",
g_hakem_config.thp_policy == THP_POLICY_OFF ? "off" :
g_hakem_config.thp_policy == THP_POLICY_AUTO ? "auto" :
g_hakem_config.thp_policy == THP_POLICY_ON ? "on" : "unknown");
fprintf(stderr, " Evo phase: %s\n",
HAKMEM_LOG(" Evo phase: %s\n",
g_hakem_config.evo_phase == EVO_PHASE_LEARN ? "learn" :
g_hakem_config.evo_phase == EVO_PHASE_FROZEN ? "frozen" :
g_hakem_config.evo_phase == EVO_PHASE_CANARY ? "canary" : "unknown");
fprintf(stderr, "\n");
fprintf(stderr, "Parameters:\n");
fprintf(stderr, " ELO frozen strategy: %d\n", g_hakem_config.elo_frozen_strategy);
fprintf(stderr, " Batch threshold: %zu bytes\n", g_hakem_config.batch_threshold);
fprintf(stderr, " Verbose level: %d\n", g_hakem_config.verbose);
fprintf(stderr, "========================================\n\n");
HAKMEM_LOG("\n");
HAKMEM_LOG("Parameters:\n");
HAKMEM_LOG(" ELO frozen strategy: %d\n", g_hakem_config.elo_frozen_strategy);
HAKMEM_LOG(" Batch threshold: %zu bytes\n", g_hakem_config.batch_threshold);
HAKMEM_LOG(" Verbose level: %d\n", g_hakem_config.verbose);
HAKMEM_LOG("========================================\n\n");
}
// ===========================================================================
@ -323,12 +324,12 @@ HakemFeatureSet hak_features_for_mode(const char* mode_str) {
}
void hak_features_print(HakemFeatureSet* fs) {
fprintf(stderr, "Feature Set:\n");
fprintf(stderr, " alloc: 0x%08x\n", fs->alloc);
fprintf(stderr, " cache: 0x%08x\n", fs->cache);
fprintf(stderr, " learning: 0x%08x\n", fs->learning);
fprintf(stderr, " memory: 0x%08x\n", fs->memory);
fprintf(stderr, " debug: 0x%08x\n", fs->debug);
HAKMEM_LOG("Feature Set:\n");
HAKMEM_LOG(" alloc: 0x%08x\n", fs->alloc);
HAKMEM_LOG(" cache: 0x%08x\n", fs->cache);
HAKMEM_LOG(" learning: 0x%08x\n", fs->learning);
HAKMEM_LOG(" memory: 0x%08x\n", fs->memory);
HAKMEM_LOG(" debug: 0x%08x\n", fs->debug);
}
// Box Refactor line default: enable SuperSlab unless explicitly disabled by env or diet mode
int g_use_superslab = 1;