Cache Effect

Deep Dive Tools

Two key tools for our cache analysis journey:

• Trace Compass - Visualization & analysis
• Trace Event Logger - Java instrumentation

Trace Compass

• Rich visualization capabilities
• Cross-stack correlation
• Extensible analysis framework
• Perfect for understanding complex interactions

Trace Event Logger

• Java-oriented tracing
• Lightweight, easy to integrate
• Inspired by UST, simpler developer experience
• Minimal code changes required

Tracing Landscape

There are more!

Linux Kernel

• Ftrace
• LTTng Kernel
• Perf / eBPF

Linux Userspace

• LTTng UST
• UProbes
• UFtrace

Windows

• ETW (Event Tracing for Windows)
• WPA (Windows Performance Analyzer)
• PerfView

macOS

• DTrace
• Instruments
• OSLog

Java

• LTTng UST Java Agent
• JFR (Java Flight Recorder)
• Trace Event Logger

TypeScript

• OpenTelemetry JS: Industry standard, comprehensive but heavy
• Chrome DevTools: Built-in profiling, limited to browser context
• Node.js --inspect: V8 profiler integration, good for CPU/memory
• Custom JSON tracers: Lightweight, Trace Compass compatible
• Gap: No native equivalent to UST/Trace Event Logger simplicity

Trace Event Logger

• Designed for Java tracing
• UST-inspired
• Lightweight & easy integration
• Trade-off: fewer features than UST

TypeScript Instrumentation

• Similar approach to Trace Event Logger
• Generate compatible JSON output
• Lightweight & easy integration

Original TypeScript Code

import * as fs from 'fs';

export class CacheProcessor {
    async processData(data: string[]): Promise {
        console.log("Processing data batch");
        
        for (const item of data) {
            await this.processItem(item);
        }
        
        await fs.promises.writeFile('output.txt', data.join('\n'));
    }
}
          

Instrumented TypeScript Code

 import * as fs from 'fs';
+import { TraceLogger } from './trace-logger';

 export class CacheProcessor {
+    private tracer = new TraceLogger();
+    
     async processData(data: string[]): Promise {
         console.log("Processing data batch");
+        const span = this.tracer.startScope('processData', { count: data.length });
         
         for (const item of data) {
             await this.processItem(item);
         }
         
         await fs.promises.writeFile('output.txt', data.join('\n'));
+        span.end();
     }
 }
          

Simple Trace Logger Implementation

export class TraceLogger {
    private events: any[] = [];
    
    startScope(name: string, args?: any) {
        const start = Date.now() * 1000; // microseconds
        const event = {
            name, ph: 'B', ts: start, pid: process.pid, 
            tid: 0, args: args || {}
        };
        this.events.push(event);
        
        return {
            end: () => {
                this.events.push({
                    ...event, ph: 'E', ts: Date.now() * 1000
                });
            }
        };
    }
    
    writeTrace(filename: string) {
        fs.writeFileSync(filename, JSON.stringify(this.events));
    }
}
          

Extension frontend architecture

Continuously porting over features to the extension!

...where one of the latest addition is the Flame Graph

Flame Charts & Graphs

• Flame Graph: aggregated profiles
• Flame Chart: time-aligned stacks
• Complementary perspectives on performance

Flame Graph - Aggregated View

• What: Stack traces collapsed and sorted by frequency
• X-axis: Percentage of samples (width = time spent)
• Y-axis: Call stack depth
• Best for: Finding hotspots, CPU-bound bottlenecks
• Loses: Temporal information, execution order

Flame Chart - Timeline View

• What: Stack traces over time, preserving chronology
• X-axis: Time progression
• Y-axis: Call stack depth
• Best for: Understanding execution flow, cache misses, I/O waits
• Shows: When things happen, duration patterns

Why Both Matter for Cache Analysis

• Flame Graph: "Which functions are slow overall?"
• Flame Chart: "When do cache misses cause stalls?"
• Cache issues often show as temporal patterns
• Aggregation can hide intermittent problems

Flame Chart in action

A better explanation

Instrumentation Strengths

• Static instrumentation = always available
• Low overhead, high precision
• Minimal perturbation to workload

Original Code

import java.io.FileWriter;

public class SlappyWag {
    public static void main(String[] args) {
        System.out.println("The program will write hello 10x between two scope logs\n");
        try (FileWriter fw = new FileWriter("test.txt")) {
            for (int i = 0; i < 10; i++) {
                fw.write("Hello world "+ i);
            }
        }
    }
}
          

Instrumented Code

import java.io.FileWriter;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.eclipse.tracecompass.traceeventlogger.LogUtils;

public class SlappyWag {
    
    private static Logger logger = Logger.getAnonymousLogger();
    
    public static void main(String[] args) {
        System.out.println("The program will write hello 10x between two scope logs\n");
        try (LogUtils.ScopeLog sl = new LogUtils.ScopeLog(logger, Level.FINE, "writing to file"); FileWriter fw = new FileWriter("test.txt")) {
            for (int i = 0; i < 10; i++) {
                fw.write("Hello world "+ i);
            }
        }
    }
}
          

Code Results

• Traces reveal delays at cache boundaries
• Clear visualization of synchronous stalls

Overview

In depth