PCP supports an efficient memory-mapped instrumentation mechanism for extracting performance instrumentation from running programs. There are currently two implementations of the instrumentation API - one written in C and the other in Java. This project aims to allow programs written in the Go language to be instrumented with a native Go API (i.e. not using cgo).
Expected results: A native Go API, allowing Go programs to be instrumented to generate live performance metrics via the MMV shared memory format, read by the PCP pmdammv agent. And a sample application demonstrating use of the API.
Prerequisite knowledge: Go programming, C a plus
Skill level: Intermediate
Mentors: Lukas Berk (primary), Owen Butler (backup), Nathan Scott (backup)
Flame graphs are a visualization of profiled software, allowing frequently travelled code paths to be identified quickly and accurately. This project idea explores possible interactions between the Vector web application, the Linux kernel eBPF and/or perf facilities, and the PCP pipe agent pmdapipe
Expected results: A capability for rendering flame graphs on-demand over a given time interval is available from the Vector web application.
Prerequisite knowledge: Javascript, C programming, Linux kernel
Skill level: Intermediate
Mentors: Martin Spier (primary), Dave Brolley (backup), Lukas Berk (backup)
PCP has an agent-based architecture for extracting performance data. Agents are responsible for making live metric values available to monitoring tools. Today, agents can be implemented in C, C++, Perl and Python - this project will extend that set to include agents written in the Go language.
Expected results: An API binding allowing Go PCP agents, and at least one sample agent demonstrating that binding.
Prerequisite knowledge: C programming, Go a plus
Skill level: Intermediate
Mentors: Lukas Berk (primary), Owen Butler (backup), Nathan Scott (backup)
Jolokia.org "is remote JMX with JSON over HTTP", and can be used to extract live performance data from an unmodified Java application.
PCP is a handy performance data sink and analysis toolkit; the goal here is to build a PCP agent to extracted JVM metrics (accessed over JSON/HTTP) from Jolokia for the PCP analysis tools to consume (i.e. for charting, decision making, reporting and other analysis).
Expected results: A PCP agent that sources JVM performance data from an unmodified Java/other demo application, using Jolokia.
Prerequisite knowledge: Java and either Python or C programming
Skill level: Intermediate
Mentors: Nathan Scott (primary), Paul Smith (backup), Roland Huss (backup)
PCP has an agent-based architecture for extracting performance data. Agents are responsible for making live metric values available to monitoring tools. Today, agents can be implemented in C, C++, Perl and Python - this project will extend that set to include Ruby.
Expected results: An API binding allowing Ruby PCP agents, and at least one sample agent demonstrating that binding.
Prerequisite knowledge: Ruby and C programming
Skill level: Intermediate
Mentors: Ryan Doyle (primary), Nathan Scott (backup)
The PCP pmlogger records statistics from a running machine. Some of these metrics vary frequently over time, but there is a large subset that vary infrequently.
This project will implement changes to pmlogger to only log these metrics when the metric values or set of instances changes. A secondary phase will involve post-processing existing log files to remove duplicate information.
Expected results: A new command line option to pmlogger to only log changing metrics, and a utility to prune existing archives.
Prerequisite knowledge: C programming
Skill level: Intermediate-Advanced
Mentors: Martins Innus (primary), Ken McDonell (backup), Dave Brolley (backup)
The Linux kernel block tracing utility extracts crucially important device transfer information in real time, which is reported by the blktrace utility.
This project involves building an interface between this facility and the PCP monitoring tools, via a new blktrace agent (live) and/or log data import (historical).
Expected results: New PCP blktrace data consumers are built such that PCP monitoring tools like pmevent can consume the metrics made available.
Prerequisite knowledge: C programming, Linux kernel
Skill level: Advanced
Mentors: Mark Goodwin (primary), Ken McDonell (backup)
There are many handy text-based system analysis tools available on modern Linux platforms - tools like htop , mpstat , pidstat , nfsstat and so on. These programs are quite simple, but while they allow good live-system analysis, they lack historical reporting (to answer questions like "what was happening on the system at 2am last Tuesday?").
PCP makes it easy to access both historical and live performance data from client programs and (Python) scripts. This project involves extending (and/or re-implementing) performance tools from the above list, using PCP APIs to solve the historical query aspect. Students can expect to gain insight into the meaning of the kernel data reported by these tools, and the sampling techniques used in building the tools.
Expected results: Build and test versions of a selection of system tools using PCP APIs to provide new functionality.
Prerequisite knowledge: Intermediate C, Python programming
Skill level: Basic-Intermediate
Mentors: Ryan Doyle (primary), Nathan Scott (backup), Mark Goodwin (backup)
PCP has been ported to many platforms, including Linux, Solaris, FreeBSD, Mac OS X and also Windows. The native Windows port was achieved using the MinGW-w64 toolchain and cross-compilation from Fedora. This project involves producing installable MSI packages using the open source msitools or WiX packages.
Expected results: Demonstrated monitoring of Windows servers with 64-bit PCP code. Installation via MSI package.
Prerequisite knowledge: C and C++ programming, XML, Windows APIs
Skill level: Intermediate
Mentors: Nathan Scott (primary), Ken McDonell (backup)