hyperfine is a command-line benchmarking tool designed to measure the performance of arbitrary commands with statistical rigor. It executes commands multiple times, collects metrics such as wall-clock time, CPU time, memory usage, and hardware counters, and provides comparative analysis with confidence intervals and outlier detection. The tool supports warmup runs, parameterized benchmarks (e.g., varying thread counts), and various export formats (CSV, JSON, Markdown) for further analysis. The architecture is modular, separating concerns such as command-line parsing, command representation, benchmark execution, metric collection, and result exporting. It uses a pluggable executor strategy to handle direct command execution, shell-mediated execution (with overhead calibration), and mock execution for testing. Cross-platform support is achieved through conditional compilation and abstractions for platform-specific timing and hardware counter collection. Notable reusable components include utilities for environment randomization to mitigate memory layout effects, a numeric type union for handling integer and decimal parameters, shell syntax detection for safe command parsing, quantity type aliases with serialization support, and cross-platform exit code extraction. The codebase demonstrates strong engineering practices in handling real-world benchmarking complexities like shell overhead, caching effects, and statistical noise.
pprof is a mature, production-grade profiling visualization and analysis tool for Go, C++, Java, and other languages that export profiles in the pprof protobuf format. It operates as both a command-line tool and an interactive web server, allowing users to inspect CPU, memory, contention, and goroutine profiles. The core architecture is a modular Go application: the `driver` package orchestrates fetching, symbolization, merging, and report generation; the `profile` package provides a standalone library for reading, writing, and manipulating profiles; the `graph` package builds weighted directed call graphs; and the `report` package outputs a variety of formats including text, SVG dot graphs, HTML flame graphs, annotated source, disassembly, and more. External dependencies include binutils (addr2line, nm, objdump) for local symbolization, Graphviz (dot) for graph rendering, and optionally Chrome for browser tests. The system supports profile comparison, filtering by tags or sample labels, and can symbolize using local binaries or remote symbolz services. The profile package is designed for reuse as a standalone library, making pprof useful both as a tool and as a data processing foundation for other profiling tooling.
MySQLTuner-perl is a single-file Perl script for MySQL/MariaDB/Percona Server performance tuning and advisory. It connects to live database instances, collects metrics via SHOW commands, information_schema, and performance_schema, then provides actionable recommendations for performance, security, and resilience. The tool outputs in multiple formats (console, JSON, YAML, HTML, CSV) and includes advanced features like weighted health scoring (0-100), predictive capacity analysis, CVE vulnerability checking, replication analysis, and AI agent integration via --agent-json or MCP server. The repository enforces strict governance: zero CPAN dependencies in the main script, test-driven development, conventional commits, and automated release processes. Auxiliary scripts handle CVE updates, EOL synchronization, compliance checking, and release generation, all while maintaining high code quality and version consistency.
This repository implements an MCP (Model Context Protocol) server that exposes Chrome DevTools capabilities as tools for AI coding assistants. In production, it launches a headless or headed Chrome browser via Puppeteer, connects to the DevTools frontend SDK, and provides over 50 tools covering navigation, input automation, network inspection, performance tracing, heap snapshot analysis, CSS inspection, accessibility auditing (via Lighthouse), PWA management, and extension debugging. The architecture is a Node.js server that runs either as a long-lived daemon (Unix socket IPC) or as a CLI tool, with a configuration pipeline supporting CLI flags, config files, and environment variables. Key entry points are `src/bin/chrome-devtools-mcp.ts` (MCP server) and `src/bin/chrome-devtools.ts` (standalone CLI). Data flows involve collecting console messages, network requests, and DevTools issues per page via `PageCollector`, processing performance traces via `ChunkedTraceParser` and `PerformanceTrace`, and formatting results through specialized formatters (`ConsoleFormatter`, `CssFormatter`, `HeapSnapshotFormatter`, etc.) that support both text and structured JSON output. External dependencies include Puppeteer for browser control, the DevTools frontend SDK for advanced features (heap snapshots, stack traces), Lighthouse for audits, and a telemetry system (Clearcut) for usage statistics.
This is a Linux-only CLI benchmarking tool written in Zig that uses the `perf_event_open` syscall to measure hardware performance counters (CPU cycles, instructions, cache references/misses, branch misses) alongside wall time and peak RSS. It repeatedly executes user-specified commands, collects samples, and computes statistical summaries (mean, standard deviation, quartiles, outlier counts) with a colorful terminal UI. The tool compares multiple commands, treating the first as a reference, and displays deltas with statistical significance testing using Student's t-distribution. The codebase is small but well-crafted, demonstrating advanced use of Linux perf events, statistical analysis, and terminal rendering. It is actively maintained by Andrew Kelley (author of Zig) and serves as a practical alternative to Hyperfine for hardware-aware benchmarking.
Coz is a causal profiler for native code (C/C++, Rust, Go, Swift, Java) that uses virtual speedup experiments to identify which lines of code, if optimized, would most improve program throughput or latency. It operates by injecting a shared library (libcoz) via LD_PRELOAD or DYLD_INSERT_LIBRARIES, interposing synchronization primitives to track blocking and apply controlled delays on non-selected threads. The profiler outputs a JSON Lines profile that can be visualized with a built-in web viewer (D3.js scatter plots with loess smoothing) or analyzed via CLI. It includes an AI-assisted feature for suggesting progress point placement and optimization advice. The architecture is a hybrid: a core runtime library in C++ with language bindings for Rust, Go, Swift, and Java (JVMTI agent), plus a Python CLI that orchestrates profiling, visualization, and LLM integration. The project is a research artifact from UMass Amherst, published at SOSP 2015, and remains actively developed with modern features like streaming AI support.
Sitespeed.io is a mature, open-source web performance testing and monitoring tool that drives real browsers (Chrome, Firefox, Edge, Safari, including mobile) to collect a comprehensive set of performance metrics. It measures Core Web Vitals (LCP, INP, CLS, TTFB, FCP), visual metrics (Speed Index, filmstrip), HAR waterfalls, CPU long tasks, third-party requests, accessibility violations (via axe-core), and sustainability metrics (CO₂ estimates). The tool is used for one-off audits, CI/CD performance budgets, and continuous production monitoring, with results output as rich HTML reports, JSON, JUnit/TAP, and time-series data sent to Graphite/InfluxDB/Grafana. The architecture is plugin-based: a core message queue orchestrates a pipeline of plugins (setup → url → summarize → render). Built-in plugins handle browser testing (via Browsertime), HAR analysis (PageXray), best-practice advice (Coach), accessibility, sustainability, statistical comparison (Mann-Whitney U), performance budgets, and result storage (S3, GCS, SCP, Rsync). The CLI is built with yargs and supports ~600 options organized into topical modules. The tool is primarily delivered as a Docker image (multi-arch amd64/arm64) and an npm package. Key entry points are `bin/sitespeed.js` (CLI), `lib/sitespeed.js` (programmatic API), and `docker/scripts/start.sh` (Docker entrypoint). External dependencies include Browsertime, Coach Core, PageXray, axe-core, and the third-party-web dataset. The project has extensive CI/CD (GitHub Actions), a documentation site built with Eleventy, and a release workflow that publishes npm packages and Docker images with Sigstore signatures and SBOMs.
PerfView is a comprehensive performance analysis and diagnostics toolkit primarily for Windows, with growing Linux support. It collects, parses, and visualizes Event Tracing for Windows (ETW), .NET EventPipe, Linux perf, and CTF traces. The repository contains a WPF desktop application (PerfView.exe) for interactive stack, memory, and heap analysis, along with command-line tools (HeapDump, TraceParserGen, perfcollect) and a reusable library (Microsoft.Diagnostics.Tracing.TraceEvent) for programmatic trace processing. The architecture is modular, with core libraries for fast serialization, stack analysis, symbol resolution, and automated analysis. While the codebase is well-maintained and extensively tested, it contains some legacy components (custom compression, duplicated utilities) and conditional compilation that indicate moderate technical drift. The library components are the most reusable assets, offering patterns for binary serialization, caching, recursion safety, and event filtering.
Likwid is a comprehensive performance monitoring and benchmarking tool suite for HPC environments. It provides command-line tools (likwid-perfctr, likwid-pin, likwid-bench, likwid-powermeter, likwid-topology, etc.) and a C/Fortran/Lua library for reading hardware performance counters, managing CPU/GPU topology, controlling system features (turbo, prefetchers, RAPL power limits), and pinning threads. The architecture is modular: a core C library (liblikwid) handles low-level hardware access via MSR, PCI, MMIO, or a privileged daemon, while Lua scripts provide user-facing interfaces. External dependencies (Lua, hwloc, GOTCHA, cwisstable) are bundled. The codebase supports x86, ARM, POWER, and GPU (NVIDIA, AMD) architectures with per-architecture performance counter definitions. It is primarily an application tool, though its extensive hardware counter definitions and benchmark infrastructure also serve research purposes.
Perfolizer is a .NET performance-analysis toolkit extracted from BenchmarkDotNet. It provides statistical estimators (quantiles, MAD, variance), significance tests (Mann-Whitney, Welch), and specialized data structures such as Rqq for efficient range quantile queries. The repository is organized as a main class library, a demo executable, and two test projects, with CI that builds, tests, and publishes NuGet packages. Despite being labeled experimental, the codebase is actively developed, versioned, and shipped as a NuGet package.
This repository is a data collection and presentation project for single-board computer (SBC) benchmarks maintained by Jeff Geerling. It consists of a set of automated benchmarking scripts written in Python using the pyinfra orchestration tool, which can be run against any SSH-accessible SBC to gather standardized performance metrics including Geekbench, HPL (LINPACK), power consumption, memory bandwidth, disk I/O, GPU benchmarks, and AI inference performance. A secondary set of Ansible playbooks provides a simpler but less comprehensive alternative. All collected results are manually curated into a YAML file (web/data/results.yml) and rendered into a static Hugo website with a sortable comparison table. The repository serves as a public reference for SBC performance comparisons. While primarily a data research project focused on benchmarking hardware, it also provides reusable infrastructure for running benchmarks on any Linux or macOS system.
sysmon is a system monitoring and task management application that provides real-time visualization of system metrics through a web interface. It consists of a backend driver service built with Python/Falcon that exposes API endpoints for system data, and a frontend service available in both Python/Flask and Go implementations that serves an interactive dashboard. The application collects CPU, memory, disk, network, sensor, and process information using the psutil library, displays it via real-time charts (using SmoothieCharts) and tables, and allows process management operations (terminate, kill, suspend, resume) through a passcode-protected interface. The architecture features a clean separation between data gathering (hard.py), API endpoints (falc.py), and presentation layer (frontend templates and static assets).
This repository contains a technical book titled 'The Art of Problem-Solving in Software Engineering: How to Make MySQL Better'. It is structured as a collection of Markdown files covering MySQL internals, performance optimization, and problem-solving methodologies. The book does not contain executable code or data processing scripts; instead, it provides theoretical explanations, case studies, and references to MySQL versions 8.0.x and 5.7. Topics include transaction throttling, latch sharding, hybrid data structures, Group Replication enhancements, and performance testing techniques using tools like BenchmarkSQL and SysBench. The repository serves as an educational resource for database administrators, performance engineers, and MySQL contributors seeking to understand and resolve MySQL scalability and performance issues. It emphasizes analytical approaches over trial-and-error, drawing from computer science fundamentals such as queueing theory, distributed systems, and algorithmic optimization. While the book references benchmark results and visualizations (stored as images in the media/ directory), it does not include the raw data, scripts, or tools needed to reproduce those results. As a documentation-focused repository, it lacks traditional software engineering components like APIs, CLI tools, or reusable libraries. Its value lies in the consolidated knowledge presented across chapters, which readers can apply to MySQL tuning and troubleshooting scenarios. The content appears well-organized and researched, but the absence of runnable code or data assets limits its direct utility as a software artifact.