Pin (computer program): Difference between revisions

Revision as of 22:57, 26 August 2010

Revision as of 23:29, 26 August 2010

Line 4:

| latest release date = {{release date|11|03|2010}}

| operating_system = [[Linux]], [[Windows]]

| platform = [[IA-32]], [[x86-64]] and, [[IA-64]]

| genre = [[Instrumentation (computer programming)|Instrumentation framework]], [[Profiling (computer programming)|Profiler]]

| license = [[Proprietary software|Proprietary]], free for non-commercial use

Line 19:

==Overview==

Pin performs instrumentation by taking control of the program just after it loads into memory. It then [[Just-in-time compilation|just-in-time recompiles]] (JIT) small sections of binary code just before they are run. New instructions, which perform the analysis, are added to the recompiled code. These new instructions come from the Pintool. A large array of optimization techniques are used to obtain the lowest possible running time and memory consumptionuse overhead. As of June 2010, Pin's average base overhead is 30 per centpercent (without running a pintool)<ref>[http://www.cs.virginia.edu/kim/docs/ieeeComputer10.pdf Analyzing Parallel Programs with Pin]</ref>.

Pin is a platform for creating analysis tools. A pin tool comprises instrumentation, analysis and callback [[routineSubroutine|routines]]. Instrumentation routines are called when code that has not yet been recompiled is about to be run, and enable the insertion of analysis routines. Analysis routines are called when the code they are associated with is run. Callback routines are called when specific conditions are met, or when a certain event has occurred. Pin provides an extensive [[Applicationapplication Programmingprogramming Interface|APIinterface]] (API) for instrumentation at many abstraction levels, from a singleone instruction to an entire binary module. It also supports callbacks for many events such as library loads, system calls, signals/exceptions and thread creation events.

== Features ==

=== Instrumentation modes ===

Pin supports two modes of instrumentation called JIT mode and Probe mode. JIT mode supports all the features of Pin, while Probe mode supports a limited feature set but is muchfar faster, adding almost no overhead to program running time. JIT mode uses a just-in-time compiler to recompile all program code and insert instrumentation, while Probe mode uses [[Trampoline (computers)|code trampolines]] for instrumentation.

=== Platform independence ===

Pin was designed for tool [[Cross-platform|portability]], and despite JIT compiling from one ISA to the same ISA (and not using a single [[intermediate representation]] for all code), most of its APIs are architecture and [[operating system]] independent. It was also designed to be portable itself, carefully isolating platform-specific code from generic code, allowing the fast adaptation of Pin to new platforms. Approximately half of the code is generic and the rest is either architecture or OS dependent.<ref>[http://www.cs.virginia.edu/papers/p190-luk.pdf Pin: Building Customized Program Analysis Tools with Dynamic Instrumentation]</ref>

=== Optimizations ===

Pin uses many techniques to optimize instrumentation and analysis code, using techniques such as [[Inline function|inlining]], [[liveness analysis]] and smart [[register spilling]]. Pin performs these optimizations automatically whenever possible, without requiringneeding the userusers to insert any extra code to allow inlining. Naturally, some optimizations still require user hints, and some code structures are easier to inline than others. Direct linking of jitted code sections, a technique called ''trace linking'', and ''register binding reconciliation'', which minimizes register spilling and remapping, are also used.

===Ease of use===

Pin’s API and implementation are focused on making pin tools easy to write. Pin takes full responsibility for assuring that the instrumentation code from the pin tool does not affect the application state. Also, the API enables the instrumentation code to request many pieces of information from Pin. For example, the instrumentation code in the pin tool can use the Pin API to get the memory address being accessed by an instruction, without having to examine the instruction in detail.

==Tools==

Line 41:

* '''[http://software.intel.com/en-us/articles/intel-software-development-emulator/|Intel Software Development Emulator]''' is a pintool that enables the development of applications using instruction set extensions that are not currently implemented in hardware.

* '''CMP$IM''' is a cache profiler built using pin. <ref>[http://www.ece.umd.edu/~blj/papers/mobs2008.pdf CMP$im: A Pin-Based On-The-Fly Multi-Core Cache Simulator]</ref>

*'''PinPlay''' enables the capture and deterministic replay of the running of multithreaded programs under pin. Capturing the running of a program enableshelps the developer todevelopers overcome the non-determinism inherent toin multithreading.<ref>[http://delivery.acm.org/10.1145/1780000/1772958/p2-patil.pdf PinPlay: a framework for deterministic replay and reproducible analysis of parallel programs]</ref>

* Pin itself comes with many example tools that make use of its capabilitiesabilities. These tools are licensed under a BSD-like license.

== See also ==