Ascent

KO | EN

gitlite — search

#dotnet #nlp #deep-learning #markdown #llm #tensorflow #awesome-list #ai-agents #openai #claude

(★ 9)

A syscall-to-screen Linux telemetry platform built entirely in x86-64 assembly with zero runtime dependencies.

파일 탐색기

ZIP 다운로드

- nasm_guide.md
- - code.inc
  - data.inc
  - display.asm
  - README.md
  - sensor.c
- - .gitkeep
- - README.md
  - sensor.bpf.c
- - .gitkeep
  - sensor.bpf.c
- - sensor.bpf.c
- - .gitkeep
  - sensor.bpf.c
- - .gitkeep
  - sensor.bpf.c
- - README.md
  - sensor.bpf.c
- - README.md
  - sensor.bpf.c
- - README.md
  - sensor.bpf.c
- - .gitkeep
- - .gitkeep
.gitignore
Imp_Points.md
interview_prep.md
Makefile
README.md
VISION.md

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

```
                           █████╗ ███████╗ ██████╗███████╗███╗   ██╗████████╗
                          ██╔══██╗██╔════╝██╔════╝██╔════╝████╗  ██║╚══██╔══╝
                       ███████║███████╗██║     █████╗  ██╔██╗ ██║   ██║
                       ██╔══██║╚════██║██║     ██╔══╝  ██║╚██╗██║   ██║
                       ██║  ██║███████║╚██████╗███████╗██║ ╚████║   ██║
                       ╚═╝  ╚═╝╚══════╝ ╚═════╝╚══════╝╚═╝  ╚═══╝   ╚═╝
```

### **Multi-Strata Linux Observability Pipeline**
*Trace anomalies from surface symptoms to kernel root causes — across 11 resolution scales — rendered on a cosmic terminal dashboard written in pure x86-64 assembly.*

<br>

[![License: GPL-2.0](https://img.shields.io/badge/License-GPL%20v2-blue.svg)](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)
![Platform](https://img.shields.io/badge/Platform-Linux%205.x%2B-orange)
![Language](https://img.shields.io/badge/Dashboard-x86--64%20NASM%20Assembly-red)
![Kernel](https://img.shields.io/badge/Instrumentation-eBPF%20%2B%20PMU%20%2B%20procfs-green)
![Libc](https://img.shields.io/badge/libc%20dependencies-zero-black)

</div>

---

## The Premise

Every performance problem you've ever debugged started the same way: a symptom at the top — CPU spiking, latency climbing, the system feels wrong — and a root cause buried somewhere below, invisible.

The tools we reach for attack one layer at a time. `top` shows you processes. `strace` shows you syscalls. `perf` shows you hardware counters. You pivot between tools, correlate timestamps manually, and hope the signal hasn't changed by the time you look.

**ASCENT doesn't work like that.**

ASCENT instruments **eleven simultaneous resolution layers** of a running Linux system — from `procfs` system weather at the surface all the way down to BPF tracepoints at the scheduler, memory manager, lock subsystem, and IRQ causality chain — and renders all of it, in real time, on a single terminal dashboard written entirely in x86-64 NASM assembly with **zero libc dependencies**.

You watch the whole vertical stack at once. When something breaks, you see it cascade.

```
Macro ──► Micro ──► Nano ──► Pico ──► Femto ──► Atto ──► Zepto ──► Yocto ──► Planck ──► Quantum ──► Ω
(System)  (Procs)  (Syscall) (Kernel)  (CPU)   (Sched)   (Mem)   (Locks) (Causality) (Virt)     (AI)

Observable Symptoms ───────────────────────────────────────────────────────────────► Fundamental Causes
```

---

## The Strata

ASCENT is organized around the concept of **resolution**. A continent-scale view tells you the machine is sick. A molecule-scale view tells you which lock is strangling it. Every stratum between them narrows the aperture.

| # | Stratum | Scale | Domain | Core Question |
|---|---------|-------|--------|---------------|
| 0 | **Macro** | Continent | System Topography | *Is something wrong?* |
| 1 | **Micro** | Country | Process Demographics | *Who caused it?* |
| 2 | **Nano** | City | Syscall Frontier | *What operation?* |
| 3 | **Pico** | Street | Kernel Datapath | *Which path executed?* |
| 4 | **Femto** | Building | CPU Performance Physics | *Why is it slow?* |
| 5 | **Atto** | Room | Scheduler Dynamics | *Why did it run there?* |
| 6 | **Zepto** | Cell | Memory Ecosystem | *Why are pages moving?* |
| 7 | **Yocto** | Molecule | Synchronization & Locks | *Who is waiting?* |
| 8 | **Planck** | Atom | Execution Causality | *What caused the cascade?* |
| 9 | **Subplanck** | Electron | CPU Microarchitecture | *Why are instructions stalling?* |
| 10 | **Quantum** | Parallel Universe | Hypervisor Layer | *Is virtualization the culprit?* |
| Ω | **Semantic** | Human Reasoning | AI Inference | *What does all of this mean?* |

---

## Build Status

| Stratum | Status | Sensor | Collection Method | Key Signals |
|---------|--------|--------|-------------------|-------------|
| **0 — Macro** | ✅ **Live** | `sensor.c` | procfs polling @ 100ms | `/proc/stat`, `/proc/meminfo`, `/proc/loadavg`, `/proc/diskstats`, `/proc/net/dev`, `/proc/pressure/*` |
| **1 — Micro** | ✅ **Live** | `sensor.bpf.c` | eBPF ring-buffer | `sched_switch`, `sys_enter_execve`, `mm_page_alloc`, `block_rq_complete` |
| **2 — Nano** | ✅ **Live** | `sensor.bpf.c` | eBPF `raw_syscalls` tracepoints | Per-PID syscall frequency + latency (hash maps) |
| **3 — Pico** | ✅ **Live** | `sensor.bpf.c` | eBPF `fentry`/`fexit` | `vfs_read`, `vfs_write`, `ext4_read_iter`, `submit_bio`, `tcp_sendmsg`, `tcp_recvmsg` |
| **4 — Femto** | ✅ **Live** | `sensor.bpf.c` + PMU loader | `perf_event_open()` on CPU 0 | Cycles, instructions, cache misses, branch misses |
| **5 — Atto** | ✅ **Live** | `sensor.bpf.c` | eBPF `tp_btf/sched_switch` + `sched_wakeup` | Per-CPU runqueue, wakeup latency, task migrations |
| **6 — Zepto** | ✅ **Live** | `sensor.bpf.c` | eBPF mm tracepoints + `/proc/vmstat` | Page alloc/free, kswapd, reclaim, compaction, swap |
| **7 — Yocto** | ✅ **Live** | `sensor.bpf.c` | eBPF lock tracepoints + `/proc/locks` | `mmap_lock` acquire/release/contention, active file locks |
| **8 — Planck** | ✅ **Live** | `sensor.bpf.c` | eBPF IRQ/softirq/workqueue tracepoints | IRQ entries, softirqs, workqueues, context switches, wakeup chains |
| **9 — Subplanck** | 🟡 Scaffold | — | Intel PT / PEBS / LBR *(planned)* | Pipeline stalls, µop retirement, speculation failures |
| **10 — Quantum** | 🟡 Scaffold | — | KVM tracepoints *(planned)* | VM exits, EPT faults, steal time |
| **Ω — Semantic** | 🟡 Scaffold | — | Knowledge Graph + LLM *(planned)* | Cross-strata anomaly correlation |

---

## Architecture

```
┌─────────────────────────────────────────────────────────────────────────┐
│                          sensor.c  (C / root)                           │
│                                                                         │
│  ┌─────────────────┐  ┌────────────────────────┐  ┌─────────────────┐  │
│  │  procfs polling  │  │     eBPF Sensors        │  │   PMU Counters  │  │
│  │     (100ms)      │  │   (8 BPF programs)      │  │ perf_event_open │  │
│  │                  │  │                          │  │                 │  │
│  │  /proc/stat      │  │  Micro  — ring-buffer    │  │  cycles         │  │
│  │  /proc/meminfo   │  │  Nano   — hash map       │  │  instructions   │  │
│  │  /proc/loadavg   │  │  Pico   — hash map       │  │  cache misses   │  │
│  │  /proc/diskstats │  │  Atto   — hash map       │  │  branch misses  │  │
│  │  /proc/net/dev   │  │  Zepto  — hash map       │  │                 │  │
│  │  /proc/pressure/ │  │  Yocto  — hash map       │  └─────────────────┘  │
│  │  /proc/uptime    │  │  Planck — hash map       │                       │
│  └────────┬─────────┘  └────────────┬─────────────┘                       │
│           └────────────────┬─────────┘                                    │
│                            │                                              │
│                   ascent_event (60 bytes fixed)                          │
└────────────────────────────┼─────────────────────────────────────────────┘
                             │
                  /tmp/ascent.pipe  (named FIFO)
                             │
┌────────────────────────────┼─────────────────────────────────────────────┐
│                            │      display.asm  (x86-64 NASM)             │
│                                                                          │
│  ╔════════════════════════════════════════════════════════════════════╗  │
│  ║                  ✦  ASCENT — STRATA 0–8  ✦                       ║  │
│  ╠════════════════════════════════════════════════════════════════════╣  │
│  ║  CPU: 45%   MEM: 62%   LOAD: 1.20   UP: 00142m                  ║  │
│  ║  DSK: 0234  RX: 1250KB  TX: 0893KB                               ║  │
│  ║  PSI cpu: 0.5   PSI mem: 1.2   PSI io: 0.0                      ║  │
│  ╠════════════════════════════════════════════════════════════════════╣  │
│  ║  > bash                  > systemd-journal                        ║  │
│  ║  > gnome-shell           > Xorg                                   ║  │
│  ║  > … (18-entry process ring-buffer)                               ║  │
│  ╠════════════════════════════════════════════════════════════════════╣  │
│  ║  SYS:   pid=12345  call=0    cnt=00001234  lat=00005678ns        ║  │
│  ║  PICO:  vfs_read   cnt=00000008  lat=00004567ns                  ║  │
│  ║  FEMTO: IPC=1.25   cache=02.3%   br=00.5%                       ║  │
│  ║  ATTO:  cpu=008  sw=000123  lat=0042µs  mig=000005              ║  │
│  ║  ZEPTO: alloc=001234  free=001100  pgfl=000567                   ║  │
│  ║         rec=00045  cmp=0003                                       ║  │
│  ║  YOCTO: acq=000123  rel=000119  ctn=3.2%  act=0045             ║  │
│  ║  PLANCK: irq=001234  sirq=000567  csw=008901                    ║  │
│  ║░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░║  │
│  ╚════════════════════════════════════════════════════════════════════╝  │
└──────────────────────────────────────────────────────────────────────────┘
```

### IPC Protocol — The 60-Byte Event Spine

Every stratum funnels into one fixed-size binary struct written to `/tmp/ascent.pipe`. The display deserializes and renders without a single heap allocation.

```
Offset  Size  Field    Macro(0)        Micro(1)        Nano(2)         Pico(3)         Femto(4)        Atto(5)         Zepto(6)        Yocto(7)        Planck(8)
──────  ────  ───────  ──────────────  ──────────────  ──────────────  ──────────────  ─────────────   ─────────────   ─────────────   ─────────────   ──────────────
  0      4    type     0               1               2               3               4               5               6               7               8
  4      4    val1     cpu_pct         pid             sys_pid         func_id         ipc×100         active_cpus     page_alloc      mmap_acquires   irq_entries
  8      4    val2     mem_pct         ppid            syscall_id      count_lo        cache%×100      switches        page_free       mmap_releases   softirq_entries
 12      4    val3     load×100        thread_count    count_lo        count_hi        br%×100         lat_us          reclaim_wake    contentions     work_start
 16      4    val4     disk_iops       —               count_hi        lat_lo          cycles_lo       migrations_lo   direct_reclaim  flock_ops       wakeups
 20      4    val5     net_rx_kb       —               lat_lo          lat_hi          cycles_hi       migrations_hi   compact_begin   active_locks    irq_total_delta
 24      4    val6     net_tx_kb       —               lat_hi          —               —               —               compact_end     —               context_switches
 28      4    val7     psi_cpu_100     —               —               —               —               —               —               —               —
 32      4    val8     psi_mem_100     —               —               —               —               —               page_faults     —               —
 36      4    val9     psi_io_100      —               —               —               —               —               —               —               —
 40      4    val10    uptime_min      —               —               —               —               —               —               —               —
 44     16    comm     —               comm[16]        —               —               —               —               —               —               —
```

---

## Strata Deep-Dive

### ◈ Strata 0 — Macro · *System Topography*
> *"Is the machine on fire?"*

Polls seven `/proc` files every 100ms. No kernel privileges needed. This is the weather forecast — you can't fix anything from here, but you can tell instantly that something needs fixing.

**Signals:** CPU%, memory pressure, load average, disk IOPS, network throughput (RX/TX KB), PSI stall scores for CPU/mem/IO, uptime.

---

### ◈ Strata 1 — Micro · *Process Demographics*
> *"Who is responsible?"*

An eBPF ring-buffer captures `sched_switch`, `execve`, page alloc, and block completions. An 18-slot rolling ring in the display shows you the most recently active processes — not a static snapshot, but a live stream of what's actually running.

**Signals:** Process name, PID, PPID, thread count, context-switch frequency.

---

### ◈ Strata 2 — Nano · *Syscall Frontier*
> *"What operation is happening at the user↔kernel boundary?"*

`raw_syscalls/sys_enter` and `sys_exit` tracepoints feed per-PID, per-syscall hash maps. Latency is accumulated in-kernel; the loader reads deltas.

**Signals:** Hottest syscall by PID — call number, invocation count, total latency (ns).

---

### ◈ Strata 3 — Pico · *Kernel Datapath*
> *"Which path inside the kernel is executing?"*

`fentry`/`fexit` hooks on six critical kernel functions instrument the VFS, block, and TCP paths with nanosecond timestamps. No patching, no recompile — CO-RE BPF.

**Functions probed:** `vfs_read`, `vfs_write`, `ext4_read_iter`, `submit_bio`, `tcp_sendmsg`, `tcp_recvmsg`

**Signals:** Hottest kernel function, call count, cumulative latency.

---

### ◈ Strata 4 — Femto · *CPU Performance Physics*
> *"Why is execution slow? Is the CPU actually working or just waiting?"*

`perf_event_open()` opens hardware PMU counters directly. IPC below 1.0 means the CPU is starved — probably memory-bound. High cache-miss rate confirms it.

**Signals:** IPC (instructions per cycle), L1/LLC cache miss %, branch misprediction %.

---

### ◈ Strata 5 — Atto · *Scheduler Dynamics*
> *"Why did this task run when it did? Is it bouncing between cores?"*

`tp_btf/sched_switch` and `tp_btf/sched_wakeup` give nanosecond timestamps for every scheduling decision. Wakeup-to-schedule latency tells you how backed-up the runqueue is. Migration count tells you if the load balancer is thrashing.

**Signals:** Active CPUs, total context switches, avg wakeup latency (µs), task migrations.

---

### ◈ Strata 6 — Zepto · *Memory Ecosystem*
> *"Why are pages moving? Is there memory pressure?"*

Seven mm tracepoints plus `/proc/vmstat` delta paint a real-time picture of the virtual memory subsystem: allocations, frees, kswapd wakeups, direct reclaim events, compaction passes, swap storms.

**Tracepoints:** `mm_page_alloc`, `mm_page_free`, `mm_vmscan_kswapd_wake`, `mm_vmscan_direct_reclaim_begin`, `mm_compaction_begin/end`, `mm_swapin`, `mm_swapout`

**Signals:** Page alloc/free rate, page fault delta, reclaim events, compaction events.

---

### ◈ Strata 7 — Yocto · *Synchronization & Locks*
> *"Who is blocking whom?"*

`mmap_lock_acquire_returned` and `mmap_lock_released` tracepoints track acquire/release pairs. Contention rate is computed in-kernel. `/proc/locks` gives the active file-lock count.

**Signals:** mmap_lock acquires, releases, contention %, active POSIX/flock file locks.

---

### ◈ Strata 8 — Planck · *Execution Causality*
> *"What caused this cascade?"*

The deepest live stratum. IRQ entry/exit → softirq entry/exit → workqueue execute → `sched_wakeup` forms a traceable causal chain. Combined with `/proc/interrupts` and `/proc/stat` context-switch deltas, you can watch an interrupt arrive and follow its consequences through every layer above it.

**Signals:** IRQ entries, softirq entries, workqueue starts, wakeups, total context switches, interrupt delta.

---

### ◈ Strata 9–Ω · *Scaffold — The Frontier*

| Stratum | Planned Mechanism | What It Unlocks |
|---------|-------------------|-----------------|
| **9 — Subplanck** | Intel PT / PEBS / LBR | CPU pipeline stalls, µop retirement, speculation failures — *why individual instructions are slow* |
| **10 — Quantum** | KVM tracepoints | VM exit rates, EPT faults, steal time — *is the hypervisor the bottleneck?* |
| **Ω — Semantic** | Knowledge Graph + LLM | Correlated anomaly detection across all strata — *automated root cause narration* |

---

## Tech Stack

| Component | Language / Tool | Why |
|-----------|----------------|-----|
| Sensor / Loader | **C** (`gcc`) | procfs polling, BPF map reads, PMU management, pipe I/O |
| BPF Sensors | **C** (`clang -target bpf`) | 8 kernel-side programs — tracepoints, fentry/fexit, ring-buffer, hash maps |
| Dashboard | **x86-64 NASM Assembly** | Zero dependencies, static ELF — no libc, no malloc, no runtime |
| IPC | **Named FIFO** (`/tmp/ascent.pipe`) | 60-byte fixed structs, lock-free producer/consumer |
| Build | **GNU Make** | BPF → C → NASM → linker, single `make` |
| Kernel Interface | **libbpf** + **vmlinux.h (CO-RE)** | Portable BPF programs — no kernel headers, runs across kernel versions |
| PMU Interface | **`perf_event_open` syscall** | Direct hardware counter access, no perf daemon |

---

## Graceful Degradation

The loader is designed to work at every privilege level — you always get *something* useful.

| Privilege Level | Active Strata | Behaviour |
|-----------------|--------------|-----------|
| No root, no BPF | **0 only** | procfs system metrics, diagnostics printed |
| `CAP_BPF` but `perf_event_paranoid > 1` | **0–3, 5–8** | All BPF strata active; Femto PMU disabled with warning |
| Full root + `perf_event_paranoid ≤ 1` | **0–8** | Everything active, full stack |
| Display started without sensor | **None** | Blocks on pipe read — waits silently for sensor |

---

## Prerequisites

- **Linux kernel 5.x+** with BPF and BTF (`CONFIG_DEBUG_INFO_BTF=y`)
- **Toolchain:** `gcc`, `nasm`, `ld`, `clang`
- **Libraries:** `libbpf-dev`, `libelf-dev`, `libz-dev`
- **`bpftool`** — generates `build/vmlinux.h` from live kernel BTF
- **Root / `CAP_BPF`** — required for eBPF strata (Strata 0 works without)
- `/proc/sys/kernel/perf_event_paranoid ≤ 1` — required for Femto PMU counters

```bash
sudo apt install build-essential nasm clang libbpf-dev libelf-dev libz-dev bpftool

# Fedora / RHEL
sudo dnf install gcc nasm clang libbpf-devel elfutils-libelf-devel zlib-devel bpftool
```

---

## Build & Run

```bash
git clone <repo-url> ascent && cd ascent

# Build everything: BPF → C → NASM → ld
make

# One-time: create the IPC pipe
mkfifo /tmp/ascent.pipe

# Terminal 1 — sensor (procfs + eBPF + PMU)
sudo ./build/loader

# Terminal 2 — cosmic dashboard
./build/ascent
```

```bash
make clean   # remove all build artifacts
```

`Ctrl+C` on the loader cleanly detaches all BPF programs, drains maps, and closes every FD.

---

## Project Structure

```
ascent/
├── Makefile                      # BPF compilation → C linking → NASM assembly → ld
├── VISION.md                     # Full philosophy, resolution analogies, roadmap
├── Imp_Points.md                 # NASM reference: registers, syscalls, memory, loops
├── docs/
│   └── nasm_guide.md             # From-zero NASM tutorial using Ascent as the example
├── build/                        # Compiled output (gitignored)
│   ├── vmlinux.h                 # Kernel BTF headers (auto-generated by bpftool)
│   ├── micro_sensor.bpf.o        # ─┐
│   ├── nano_sensor.bpf.o         #  │
│   ├── pico_sensor.bpf.o         #  │  BPF objects, one per stratum
│   ├── femto_sensor.bpf.o        #  │
│   ├── atto_sensor.bpf.o         #  │
│   ├── zepto_sensor.bpf.o        #  │
│   ├── yocto_sensor.bpf.o        #  │
│   ├── planck_sensor.bpf.o       # ─┘
│   ├── loader                    # C sensor binary
│   └── ascent                    # NASM display binary (standalone, static ELF)
└── strata/
    ├── 0_macro/
    │   ├── sensor.c              # Loader — procfs + BPF orchestration + PMU
    │   ├── display.asm           # NASM entry point (%include data.inc + code.inc)
    │   ├── code.inc              # Render logic, event dispatch, utility routines
    │   └── data.inc              # ANSI sequences, box frames, display buffers, palette
    ├── 1_micro/sensor.bpf.c      # Process ring-buffer
    ├── 2_nano/sensor.bpf.c       # Syscall hash maps
    ├── 3_pico/sensor.bpf.c       # VFS / block / TCP fentry/fexit
    ├── 4_femto/sensor.bpf.c      # PMU map shim
    ├── 5_atto/sensor.bpf.c       # Scheduler tracepoints
    ├── 6_zepto/sensor.bpf.c      # Memory manager tracepoints
    ├── 7_yocto/sensor.bpf.c      # Lock tracepoints
    ├── 8_planck/sensor.bpf.c     # IRQ / softirq / workqueue / wakeup chains
    ├── 9_subplanck/              # [ scaffold — Intel PT / PEBS / LBR ]
    ├── 10_quantum/               # [ scaffold — KVM tracepoints ]
    └── omega_semantic/           # [ scaffold — Knowledge Graph + LLM ]
```

---

## Known Limitations

- BPF ring-buffer events (Strata 1 — process data) require `CAP_BPF` / root
- Femto PMU counters are read from CPU 0 only, not summed across all cores
- Atto scheduler maps key by `tgid` — per-thread granularity not tracked
- The 60-byte fixed event struct will need extensible framing for Strata 9+
- No display reconnection — if `ascent` dies, `loader` gets a broken pipe and shuts down
- Strata 9–Ω have scaffolding directories but no sensors yet

---

## License

**GPL-2.0** — required by the Linux kernel for BPF programs that use GPL-only helper functions (`bpf_ktime_get_ns`, `bpf_get_current_pid_tgid`, `bpf_ringbuf_reserve`, and friends). All BPF sensor programs declare a GPL-compatible license.

---

## Further Reading

- [`VISION.md`](VISION.md) — Full project philosophy, resolution analogies, data flow diagrams, and the complete roadmap
- [`docs/nasm_guide.md`](docs/nasm_guide.md) — A from-zero NASM tutorial built entirely on Ascent's codebase as the teaching example
- [`Imp_Points.md`](Imp_Points.md) — NASM assembly quick-reference: registers, syscall calling convention, memory addressing, loops

---

*Built to see what no single tool can show you.*

</div>

Ascent

파일 탐색기

# CDN으로 사용하기

Was this content helpful?

Recent Feedback

Download README