All Classes and Interfaces
Class
Description
Adaptive AST Optimizer dynamically reordering commutative boolean clauses
based on live cost-to-failure ratios (C_i / F_i) or pluggable ReorderingPolicy SPI,
and executing zero-downtime bytecode hot-swapping into tiered rule caches.
JMH Microbenchmark suite measuring unoptimized static AST vs adaptively reordered AST
execution throughput and latency under skewed traffic distributions, and verifying
non-ML baseline rule evaluation (invalid input: '<' 10 ns).
Thread-safe callback receiver invoked from instrumented bytecode during method entry, exit, or object allocation.
Configuration holder for Java Agent startup parameters and options.
Configuration options for the Helix Java Agent instrumentation.
Entry points for the Helix Java Agent (premain for static attachment, agentmain for dynamic attachment).
Static callback target invoked from ASM-instrumented bytecode upon object instantiation.
Registry and metric collector for tracking object allocations across instrumented classes.
ASM ClassVisitor intercepting NEW, NEWARRAY, and ANEWARRAY bytecode instructions to inject allocation callbacks.
High-performance Unicode ASCII Flame Graph Renderer.
Represents a single positioned frame bar in the terminal layout.
Modern floating toast notification anchored to the top-right corner of the terminal.
High-performance terminal utility for rendering cleanly aligned ASCII tables.
Low-level ASM bytecode generator for high-performance rule compilation with direct ONNX inference invocations.
Low-level ASM class builder for generating JVM bytecode structures.
Low-level ASM bytecode generator for high-performance rule compilation.
Low-level ASM helper for emitting stack bytecode instructions.
Expression tokenizer and recursive descent AST parser.
AST Visitor that evaluates expressions dynamically against an
ExecutionContext.Deterministic node identifier resolver ensuring consistent naming across
AST profiling hooks and adaptive AST optimizers.
High-performance, thread-safe AST node profiler capturing per-node execution telemetry.
Renders colorized Unicode tree visualizations of Helix AST structures.
Visitor interface for AST node traversal and code generation.
Asynchronous rule executor using
CompletableFuture backed by a configurable ThreadPoolExecutor.Controller providing Java API integration for async-profiler (CPU, allocation, lock profiling).
Parallel batch rule executor for bulk context processing using parallel streams and configurable parallelism.
Runner harness for JMH benchmarks.
AST node representing general binary expressions (arithmetic and logical operations).
AST node representing binary operations (+, -, *, /, >, >=, <, <=, ==, !=, &&, ||).
ByteBuddy-based bytecode generator that dynamically generates Java classes implementing
CompiledRule.Runtime delegation handler for generated CompiledRule instances.
Binary serialization codec for compiled JVM rule bytecode and associated metadata.
ASM Bytecode Compiler capable of standard zero-overhead compilation and
dynamic debug instrumentation injecting probe hooks before condition branch jumps.
Disassembles compiled JVM bytecode into human-readable HotSpot assembly representation
matching
javap -v output, powered by ASM's TraceClassVisitor.Exception thrown when dynamic bytecode generation fails.
Strategy interface for compiling AST expression trees into executable
CompiledRule instances.Bytecode & AST Optimizer engine orchestrating constant folding and dead code elimination passes.
JMH Microbenchmark suite measuring L1/L2/L3 cache lookup throughput, hit vs miss latency, and eviction overhead.
Picocli top-level command for distributed and tiered rule cache administration.
Record representing a cache event (hit, miss, put, eviction).
JFR Event triggered upon cache eviction.
Redis Pub/Sub subscriber listening on cluster invalidation channels.
Immutable cache key combining rule name, version, and input schema hash.
JFR Event triggered upon ClassLoader creation.
Record holding metadata about a registered ClassLoader in the JVM.
Utility for monitoring and detecting un-garbage-collected (leaked) ClassLoaders.
Lifecycle manager for
RuleClassLoader instances across different IsolationModes.Base interface for all Helix CLI commands.
Offset commitment modes for Kafka partition consumer streams.
AST node specifically representing comparison and relational expressions
(>, <, >=, <=, ==, !=).
JMH Microbenchmark suite measuring rule compilation latency and throughput across simple vs complex rules.
Record representing a rule compilation event.
Record representing a single JIT compilation event extracted from JVM PrintCompilation output.
Thread-safe container holding historical JIT compilation events with filtering capabilities.
Performance metrics tracking stage-by-stage compilation duration in nanoseconds.
Observer that collects and analyzes HotSpot JIT compilation events during experiment runs.
Aggregated metrics and statistical summary computed from JIT compilation events.
Represents a compiled, executable rule instance.
Represents an identifiable condition clause within a rule AST that can hold breakpoints.
AST Optimization pass that performs constant folding on literal expressions.
Renderer that formats JIT, GC, Cache, and Memory metrics into a clean, boxed terminal dashboard view.
AST Optimization pass that eliminates unreachable branches and redundant constant logical terms.
Static probe hook invoked directly by ASM-instrumented bytecode prior to condition branch jumps.
Manages an interactive debug session with breakpoints, stepping, and frame stack inspection.
Default implementation of
Profiler tracking engine telemetry events.Default implementation of
RuleEngine orchestrating compilation and execution.Policy defining conditions for demoting cache entries across tiers.
Configuration options for the LMAX Disruptor streaming engine.
Ultra-low latency, zero-allocation in-process streaming engine backed by the
LMAX Disruptor ring buffer pattern with cache-line padded events and virtual thread
event processing.
JMH Microbenchmark suite measuring sustained ring buffer streaming throughput
(>1,500,000 events/sec) and latency percentiles (P50, P99) with LMAX Disruptor.
Contract for out-of-process distributed rule cache tiers (e.g.
Generator that creates unique dynamic classes in individual custom ClassLoaders.
Event representation emitted across the engine lifecycle.
Health check evaluator that inspects engine components for Metaspace usage, ClassLoader leaks,
cache effectiveness, and GC pressure.
Thread-safe collector for core engine operational metrics (counters, gauges, and timers).
Immutable snapshot of JVM execution frame state at an AST condition evaluation point.
Thread-safe EventBus supporting synchronous and asynchronous event publishing and type-safe subscriptions.
JMH Microbenchmark suite measuring rule execution throughput (cold vs hot rules, concurrent execution).
Encapsulates variables and state passed into a rule execution.
Record representing a rule execution event.
Method visitor using AdviceAdapter to inject entry and exit hooks into rule methods.
Contract for evaluating AST nodes or executing rule logic dynamically during runtime interception.
Holds the output outcome of a rule execution, including execution state, result value, duration, and potential errors.
Per-thread execution metrics tracking method entry times, execution counts, and duration totals.
Metrics collector for tracking rule execution performance and counts.
Unified CLI entrypoint to list and execute JVM performance experiments.
Base interface for all nodes in the Abstract Syntax Tree.
Exception thrown when expression syntax parsing fails, providing line, column, and visual pointers.
High-performance, lightweight recursive-descent parser for human-readable rule expressions.
AST node representing context property and field navigation (e.g.
In-memory folded stack trace aggregation engine that transforms execution and allocation samples
from internal profilers, thread dumps, and JDK Flight Recorder (JFR) into hierarchical flame graph call trees.
Interactive Lanterna GUI component that displays the Unicode box-drawing flame graph.
Generator that converts collapsed stack samples into interactive HTML flame graphs.
Complete interactive Lanterna Flame Graph panel containing the canvas,
breadcrumb navigation, frame statistics inspector, and keyboard control legend.
Color and theme management for flame graph visualization in terminal TUIs and ANSI consoles.
AST node representing built-in or registered function invocations (e.g.
Record representing a Garbage Collection event parsed from JDK Unified GC Logging (-Xlog:gc*).
Parser for JDK Unified GC log lines (-Xlog:gc*).
Main GC log analyzer that parses unified GC logs (-Xlog:gc*), tracks GC statistics,
safepoint pauses, and notifies listeners of GC events.
Report summarizing GC stress experiment outcomes for Soft and Weak reference clearing.
Summary statistics computed from GC events.
Experiment evaluating GC behavior with SoftReferences under memory pressure
vs immediate GC collection of WeakReferences.
Record representing a specific health issue or anomaly detected during health check.
Summary record representing system health status.
Main application entrypoint for the Helix JVM Scripting Engine & Profiler CLI/TUI.
Advanced Lanterna-based interactive TUI Dashboard for live JVM monitoring and Flame Graph profiling.
Public programmatic factory facade for creating and configuring
Helix RuleEngine and Profiler instances for embedded environments.
Custom JDK Flight Recorder (JFR) event emitting per-node profiling telemetry.
Interactive JLine 3 Terminal REPL and HotSpot Bytecode Disassembler for Helix.
Auto-completer for the Helix REPL.
Real-time syntax highlighter for the Helix REPL.
JLine 3 Parser for the Helix REPL supporting multiline expression editing.
Analyzer that parses HotSpot inlining logs (-XX:+PrintInlining) to inspect JIT method inlining decisions.
Record representing a single JIT inlining decision.
Callback interface invoked when class bytecode instrumentation occurs.
Strategy mode determining ClassLoader isolation and sharing behavior.
Service for emitting custom Helix JFR events to Flight Recorder.
Manager for managing JDK Flight Recorder (JFR) recording sessions programmatically.
Experiment demonstrating HotSpot Tiered Compilation progression (Tier 0 -> Tier 1-3 C1 -> Tier 4 C2)
and inlining size thresholds.
Monitor that parses HotSpot JIT compilation logs (-XX:+PrintCompilation)
and emits structured CompilationEvent objects.
Report summarizing observed JIT compilation tiers, invocation counts, and inlining decisions.
Dedicated JSON output formatter for schema-driven machine-readable pipeline mode.
Utility for loading JSON rules from file system, classpath resources, or input streams.
Serializer and deserializer for Kafka stream records, rule events, and execution results.
Enterprise clustered Kafka stream consumer supporting partition-level parallelism,
virtual thread fan-out, dynamic rebalance listeners, and backpressure control via pause/resume.
High-performance Kafka producer for streaming rule events and structured evaluation results.
Configuration for clustered Kafka rule streaming ingestion and result publishing.
Enterprise clustered Kafka streaming engine implementing
StreamBridge.JMH Microbenchmark suite comparing:
1.
Picocli subcommand for inspecting and administering the L4 Redis distributed rule cache.
Configuration parameters for Helix Redis L4 distributed rule caching.
Enterprise L4 Distributed Rule Cache backed by Redis.
Report summarizing JOL object memory layout, header sizes, padding, and compressed oops settings.
AST node representing literal values (numbers, booleans, strings).
Interactive Live Dashboard manager that refreshes and renders JVM stats to the terminal every 1 second.
In-memory and filesystem-backed implementation of
ModelRegistry.JFR Event triggered upon object layout memory analysis.
Record representing object layout and memory analysis output (e.g., via JOL).
Central service facade for memory layout analysis.
Experiment demonstrating Metaspace memory leaks caused by unclosed, retained ClassLoaders vs.
Summary report of Metaspace memory usage and class loading metrics.
AST node representing method invocations on a target expression (e.g.
Registry holding global operational metrics for the Helix engine.
Immutable snapshot of engine performance metrics at a specific point in time.
Metric dimension for flame graph stack trace aggregation.
Service Provider Interface (SPI) for resolving, registering, and managing
machine-learning models within the Helix rule execution engine.
Neural AST Reordering Policy utilizing the embedded ast_reorder_policy.onnx model.
Thread-safe statistics tracker for an individual AST expression node.
Experiment analyzing JVM object layouts, header overhead, alignment padding, and Compressed OOPs footprint using JOL.
Inspector utilizing JOL ClassLayout and GraphLayout for shallow/deep size calculations and layout visualization.
Extracts and transforms runtime execution context features into native ONNX tensor buffers.
JMH Microbenchmark measuring single-row inline ONNX inference latency (P50, P90, P99)
versus simulated HTTP REST inference overhead.
AST node representing an in-process machine learning inference invocation via ONNX Runtime.
Encapsulates the output and performance telemetry from an in-process ONNX model evaluation.
Metadata descriptor defining an ONNX machine-learning model artifact.
Fluent builder for
OnnxModelDescriptor.Static runtime bridge for executing ONNX model inference from compiled JVM bytecode and interpreters.
Thread-safe, high-throughput runtime session pool for in-process ONNX model inference.
Immutable snapshot of an adaptive AST optimization and hot-swap operation.
Formats CLI command output for text, json, and csv modes.
Exception thrown when JSON parsing or schema validation of a rule fails.
Comparator for comparing two collapsed profiling runs (e.g.
Report holding full comparison results between two profile datasets.
Record representing the delta comparison for a specific stack trace.
Base interface for all profiler events recorded in the Helix engine.
Listener interface for receiving profiler events.
Supported profiling event modes for async-profiler.
Core profiling interface for starting, stopping, and listening to Helix engine telemetry.
Evaluates access counters to determine whether a cache entry qualifies for tier promotion.
Analytical baseline reordering policy sorting candidate clauses in ascending
order of their cost-to-failure ratio (C_i / F_i).
Background listener running in a dedicated Java 21 virtual thread,
subscribing to Redis Pub/Sub cluster invalidation messages.
Publisher for broadcasting cache invalidation events across cluster nodes via Redis Pub/Sub.
Atomic Redis Lua scripts for concurrency-safe rule caching and stampede prevention.
Service Provider Interface (SPI) defining strategies for determining
the optimal evaluation ordering of candidate AST clauses.
Factory for instantiating and configuring
ReorderingPolicy instances.Supported AST reordering policy modes.
Picocli command to launch the interactive JLine 3 Terminal REPL and Bytecode Disassembler.
Represents an uncompiled rule definition with metadata and input requirements.
Custom URLClassLoader for dynamically defining and executing compiled rule bytecode.
ClassFileTransformer targeting rule execution classes and transforming bytecode via ASM.
JFR Event triggered upon rule compilation.
Exception thrown when a rule fails to compile.
End-to-end rule compiler orchestrating JSON parsing, AST construction, static type checking,
AST optimization, and dynamic bytecode generation.
Primary interface for compiling and executing rules within the Helix platform.
Encapsulates an in-flight rule evaluation event passed across streaming pipelines.
Pre-allocated mutable RuleEvent that avoids heap allocation in steady-state streaming.
Factory for pre-allocating padded
RuleEventHolder instances within the Disruptor RingBuffer.JFR Event triggered upon rule execution.
Exception thrown when a compiled rule fails during execution.
Interface defining execution contract for compiled rules.
Class visitor intercepting methods of rule classes to inject instrumentation adapters.
Deterministic SHA-256 key generator for compiled rules across distributed cluster nodes.
Composite AST node encapsulating a complete compiled rule definition and its parsed AST root.
Parses JSON rule definitions into valid
Rule instances with type mappings and schema validation.Convenience subclass of
StreamResult representing rule evaluation output.Data structure representing a parsed Rule definition with metadata and schema validation.
Functional handler for processing streamed rule events.
Analyzer that parses JVM safepoint log lines (-Xlog:safepoint) to monitor safepoint pauses and latency.
Record representing a single JVM safepoint event.
Experiment demonstrating JVM safepoint pauses, Time-To-Safepoint (TTSP) delays,
and safepoint monitoring under concurrent thread execution.
Report summarizing JVM safepoint latency, Time-To-Safepoint (TTSP), and pause duration.
Immutable metadata and bytecode container for distributed serialization and cache storage.
Health issue severity levels.
Singleton shared ClassLoader for common utility classes and shared dependencies.
Hierarchical prefix trie node representing a stack frame in a flame graph call tree.
Profiling telemetry event carrying a recorded execution stack trace sample.
High-performance streaming SPI bridge for in-process event ingestion,
rule evaluation, and result dispatching.
Picocli subcommand for streaming rule execution via Apache Kafka or LMAX Disruptor.
Asynchronous callback listener for stream evaluation results.
Generic record representing an item ingested into or transmitted across a stream.
Encapsulates the execution result of an event processed through the streaming pipeline.
Immutable snapshot of streaming runtime metrics and ring buffer capacity.
Synchronous implementation of
RuleExecutor executing rules in the calling thread.ANSI colored console helper for rendering CLI messages.
Tracker that monitors JIT compilation tier transitions (C1 -> C2, deoptimizations, OSR) per method.
Multi-tier rule cache supporting L1 (Strong Caffeine), L2 (SoftReference), L3 (WeakReference),
and L4 (Distributed Redis) with promotion and cluster invalidation.
Backwards-compatible alias extending
HelixDashboard.Static AST type checker and type inference engine.
Symbol table mapping variable names to their declared/inferred Java type classes,
optionally holding a
ModelRegistry for compile-time model feature verification.Exception thrown when AST type validation fails or incompatible types are encountered.
AST node representing unary operations (!, -).
AST node representing an input variable reference by name.
JMH Microbenchmark suite comparing SyncExecutor, ThreadPoolExecutor (AsyncExecutor),
and VirtualThreadRuleExecutor under concurrent evaluation load and structured fan-out.
Extended metrics tracking execution counts, timing, active virtual thread tasks, and timeouts.
High-throughput rule executor backed by Java 21 Project Loom virtual threads and structured concurrency.