A high-performance C++ analytics and 3-tier memory orchestrator. Dynamically evicts cold heaps, manages task niceness, and visualizes complex telemetry structures at scale.
Manual custom implementations of core memory trees and heaps allow operations with near-zero latency, avoiding overhead from standard library bloat.
The orchestrator combines high-frequency Linux telemetry scans with kernel priority management, governed by 3 distinct storage engine tiers.
Platform-specific Linux parser queries `/proc/[pid]/stat` and `/proc/[pid]/status` directly to fetch real-time stats including Resident Set Size (RSS), peak memory, swap space usage, CPU percentages, and page faults.
Compute process score variables (0-100) based on weighted parameters. Top 10% processes are routed to L1 (HOT), middle 40% to L2 (WARM), and the remaining 50% are relocated to L3 disk (COLD).
Modifies the Linux scheduler behavior by invoking standard `setpriority()` system bindings to boost HOT processes (-10) and de-prioritize COLD processes (10). Suspends and resumes workflows using `SIGSTOP` and `SIGCONT` signals.
L1 uses an unordered map mapped to a custom Pairing Heap to enforce capacity restrictions, L2 relies on a red-black tree (sorted by score), and L3 stores cold indexes in sequential memory vectors.
Experience the C++ orchestration engine in real-time. Select processes, preview relocations, execute promotions/demotions, and monitor cache updates.
| PID | Process Name | Class | CPU % | Memory (MB) | Page Faults | Storage Tier | Scheduling State |
|---|---|---|---|---|---|---|---|
| {{ p.pid }} | {{ p.name }} | {{ p.classification }} | {{ p.cpu.toFixed(1) }}% | {{ p.memoryMB.toFixed(0) }} MB | {{ p.faults }} | {{ p.layer }} | {{ p.state }} |
Our C++ pipeline maps collected telemetry into 7 concurrent, manually implemented data structures to deliver low-latency analytics.
Maintains process priority rankings. Insertion and peak evictions take O(log N) time, ensuring the highest hotness scores are instantly accessible for promotion queries.
Self-balancing Red-Black binary search tree sorted by process hotness scores. Keeps elements balanced to guarantee strict O(log N) lookup, insertion, deletion, and range-based querying.
A probabilistic balanced data structure built with multiple linked layers. Upper layers act as express lanes to search and sort nodes in O(log N) average time without tree rebalancing algorithms.
Doubly linked list paired with ProcessHashMap index. Relocates processes accessed via `simulateAccess()` to the HEAD of the list in O(1) time. Elements near the TAIL represent eviction candidates when the L1 Cache reaches capacity limits.
Organizes process workload timelines. Divides active system duration slots into binary segment ranges, allowing interval summation and range statistics queries in logarithmic O(log N) time.
Binary Indexed Tree storing cumulative workloads. Provides efficient prefix sum updates in O(log N) time to track system utilization changes dynamically across process groups.
How telemetry flows from standard Linux kernel system files into the storage tiers and scheduling tables.
The C++ LinuxProcessCollector scrapes virtual /proc filesystem metrics (stat and status) every 2 seconds to get RSS memory size, page fault counts, and active CPU usage times.
The Analyzer computes hotness scores (0-100) using normalizations, inserting PIDs into the HashMap, MaxHeap, and RB-Tree indexes for priority sorting.
If L1 Cache exceeds the 10% ceiling, the lowest scoring process is evicted from the Pairing Heap to L2 RAM. Cold items near the LRU TAIL are paged out to L3 Disk.
The orchestrator issues standard `setpriority()` system bindings to boost HOT workloads (-10) and demote COLD background threads (10) to optimize CPU allocation.