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: Nathan Scott (primary), Lukas Berk (backup)
There are many handy text-based analysis tools available on modern Linux platforms - tools like vmstat , mpstat , iostat , pidstat , nfsstat and so on. These programs are very simple, and while allowing good live-system analysis they lack historical reporting (to answer questions like "what was happening on the system at 2am on Tuesday?").
PCP makes it easy to access both historical and live performance data from Python scripts. This project involves implementing several performance tools from the above list in Python, using the 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 the PCP python APIs to provide new functionality.
Prerequisite knowledge: Python programming
Skill level: Basic
Mentors: Nathan Scott (primary), Mark Goodwin (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: Paul Smith (primary), Nathan Scott (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: Paul Smith (primary), Ryan Doyle (backup)
We collect PCP archives that store the state of a machine while running an application. These archives collect metrics like processor utilization, memory consumption, network utilization, etc. We have a set of algorithms that are useful in determining if an application has run inefficiently.
The student would be expected to code an implementation that would apply these algorithms to existing PCP archives to determine which applications have performed poorly.
Expected results: Scripts that can analyze application performance based on application specific algorithms.
Prerequisite knowledge: Python programming
Skill level: Intermediate
Mentors: Martins Innus (primary), Joe White (backup), 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)
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.
Expected results: A new PCP blktrace PMDA is built such that PCP monitoring tools like pmevent can consume the metrics it makes available.
Prerequisite knowledge: C programming
Skill level: Advanced
Mentors: Nathan Scott (primary), Mark Goodwin (backup), Paul Evans (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 Win32 toolchain. This project involves porting the Windows support already in the PCP codebase to using the MinGW64 compiler.
A stretch goal is the subsequent packaging work for a clean installation experience (e.g. MSI packages have been built in the past).
Expected results: Demonstrated monitoring of Windows servers with 64-bit PCP code. Installation via MSI package.
Prerequisite knowledge: C programming
Skill level: Intermediate
Mentors: Nathan Scott (primary), Ken McDonell (backup)