Pin: building customized program analysis tools with dynamic instrumentation
Robust and powerful software instrumentation tools are essential for program analysis tasks such as profiling, performance evaluation, and bug detection. To meet this need, we have developed a new instrumentation system called Pin . Our goals are to provide easy-to-use, portable, transparent , and e...
Gespeichert in:
Veröffentlicht in: | SIGPLAN notices 2005-06, Vol.40 (6), p.190-200 |
---|---|
Hauptverfasser: | , , , , , , , , |
Format: | Artikel |
Sprache: | eng |
Online-Zugang: | Volltext |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 200 |
---|---|
container_issue | 6 |
container_start_page | 190 |
container_title | SIGPLAN notices |
container_volume | 40 |
creator | Luk, Chi-Keung Cohn, Robert Muth, Robert Patil, Harish Klauser, Artur Lowney, Geoff Wallace, Steven Reddi, Vijay Janapa Hazelwood, Kim |
description | Robust and powerful software instrumentation tools are essential for program analysis tasks such as profiling, performance evaluation, and bug detection. To meet this need, we have developed a new instrumentation system called
Pin
. Our goals are to provide
easy-to-use, portable, transparent
, and
efficient
instrumentation. Instrumentation tools (called
Pintools
) are written in C/C++ using Pin's rich API. Pin follows the model of ATOM, allowing the tool writer to analyze an application at the instruction level without the need for detailed knowledge of the underlying instruction set. The API is designed to be
architecture independent
whenever possible, making Pintools source compatible across different architectures. However, a Pintool can access architecture-specific details when necessary. Instrumentation with Pin is mostly
transparent
as the application and Pintool observe the application's original, uninstrumented behavior. Pin uses
dynamic compilation
to instrument executables while they are running. For efficiency, Pin uses several techniques, including inlining, register re-allocation, liveness analysis, and instruction scheduling to optimize instrumentation. This fully automated approach delivers significantly better instrumentation performance than similar tools. For example, Pin is 3.3x faster than Valgrind and 2x faster than DynamoRIO for basic-block counting. To illustrate Pin's versatility, we describe two Pintools in daily use to analyze production software. Pin is publicly available for Linux platforms on four architectures: IA32 (32-bit x86), EM64T (64-bit x86), Itanium®, and ARM. In the ten months since Pin 2 was released in July 2004, there have been over 3000 downloads from its website. |
doi_str_mv | 10.1145/1064978.1065034 |
format | Article |
fullrecord | <record><control><sourceid>crossref</sourceid><recordid>TN_cdi_crossref_primary_10_1145_1064978_1065034</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>10_1145_1064978_1065034</sourcerecordid><originalsourceid>FETCH-LOGICAL-c195t-3b3af9822339464e26add66fd4621308701564093f4f3d9e10d628b19cf6c8703</originalsourceid><addsrcrecordid>eNotz01rAjEQxvHBWuhWe-6niM5kJmNyFOmLsGAPeg7rZgOWqmXjpd--inv6Hx544AfwSjgjEjcnVAkLP7vWIcsIKnLOGyLFMVTIag2x4BM8l_KNiIzWV_DwdThN4TE3P6V7GTqB3fvbdvVp6s3HerWsTUvBXQzvucnBW8scRKWz2qSkmpOoJUa_QHIqGDhL5hQ6wqTW7ym0WdvryhOY33_b_lxK3-X42x-OTf8XCePNEAdDHAz8Dw5ANSA</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>Pin: building customized program analysis tools with dynamic instrumentation</title><source>Access via ACM Digital Library</source><creator>Luk, Chi-Keung ; Cohn, Robert ; Muth, Robert ; Patil, Harish ; Klauser, Artur ; Lowney, Geoff ; Wallace, Steven ; Reddi, Vijay Janapa ; Hazelwood, Kim</creator><creatorcontrib>Luk, Chi-Keung ; Cohn, Robert ; Muth, Robert ; Patil, Harish ; Klauser, Artur ; Lowney, Geoff ; Wallace, Steven ; Reddi, Vijay Janapa ; Hazelwood, Kim</creatorcontrib><description>Robust and powerful software instrumentation tools are essential for program analysis tasks such as profiling, performance evaluation, and bug detection. To meet this need, we have developed a new instrumentation system called
Pin
. Our goals are to provide
easy-to-use, portable, transparent
, and
efficient
instrumentation. Instrumentation tools (called
Pintools
) are written in C/C++ using Pin's rich API. Pin follows the model of ATOM, allowing the tool writer to analyze an application at the instruction level without the need for detailed knowledge of the underlying instruction set. The API is designed to be
architecture independent
whenever possible, making Pintools source compatible across different architectures. However, a Pintool can access architecture-specific details when necessary. Instrumentation with Pin is mostly
transparent
as the application and Pintool observe the application's original, uninstrumented behavior. Pin uses
dynamic compilation
to instrument executables while they are running. For efficiency, Pin uses several techniques, including inlining, register re-allocation, liveness analysis, and instruction scheduling to optimize instrumentation. This fully automated approach delivers significantly better instrumentation performance than similar tools. For example, Pin is 3.3x faster than Valgrind and 2x faster than DynamoRIO for basic-block counting. To illustrate Pin's versatility, we describe two Pintools in daily use to analyze production software. Pin is publicly available for Linux platforms on four architectures: IA32 (32-bit x86), EM64T (64-bit x86), Itanium®, and ARM. In the ten months since Pin 2 was released in July 2004, there have been over 3000 downloads from its website.</description><identifier>ISSN: 0362-1340</identifier><identifier>EISSN: 1558-1160</identifier><identifier>DOI: 10.1145/1064978.1065034</identifier><language>eng</language><ispartof>SIGPLAN notices, 2005-06, Vol.40 (6), p.190-200</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed><cites>FETCH-LOGICAL-c195t-3b3af9822339464e26add66fd4621308701564093f4f3d9e10d628b19cf6c8703</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,780,784,27924,27925</link.rule.ids></links><search><creatorcontrib>Luk, Chi-Keung</creatorcontrib><creatorcontrib>Cohn, Robert</creatorcontrib><creatorcontrib>Muth, Robert</creatorcontrib><creatorcontrib>Patil, Harish</creatorcontrib><creatorcontrib>Klauser, Artur</creatorcontrib><creatorcontrib>Lowney, Geoff</creatorcontrib><creatorcontrib>Wallace, Steven</creatorcontrib><creatorcontrib>Reddi, Vijay Janapa</creatorcontrib><creatorcontrib>Hazelwood, Kim</creatorcontrib><title>Pin: building customized program analysis tools with dynamic instrumentation</title><title>SIGPLAN notices</title><description>Robust and powerful software instrumentation tools are essential for program analysis tasks such as profiling, performance evaluation, and bug detection. To meet this need, we have developed a new instrumentation system called
Pin
. Our goals are to provide
easy-to-use, portable, transparent
, and
efficient
instrumentation. Instrumentation tools (called
Pintools
) are written in C/C++ using Pin's rich API. Pin follows the model of ATOM, allowing the tool writer to analyze an application at the instruction level without the need for detailed knowledge of the underlying instruction set. The API is designed to be
architecture independent
whenever possible, making Pintools source compatible across different architectures. However, a Pintool can access architecture-specific details when necessary. Instrumentation with Pin is mostly
transparent
as the application and Pintool observe the application's original, uninstrumented behavior. Pin uses
dynamic compilation
to instrument executables while they are running. For efficiency, Pin uses several techniques, including inlining, register re-allocation, liveness analysis, and instruction scheduling to optimize instrumentation. This fully automated approach delivers significantly better instrumentation performance than similar tools. For example, Pin is 3.3x faster than Valgrind and 2x faster than DynamoRIO for basic-block counting. To illustrate Pin's versatility, we describe two Pintools in daily use to analyze production software. Pin is publicly available for Linux platforms on four architectures: IA32 (32-bit x86), EM64T (64-bit x86), Itanium®, and ARM. In the ten months since Pin 2 was released in July 2004, there have been over 3000 downloads from its website.</description><issn>0362-1340</issn><issn>1558-1160</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2005</creationdate><recordtype>article</recordtype><recordid>eNotz01rAjEQxvHBWuhWe-6niM5kJmNyFOmLsGAPeg7rZgOWqmXjpd--inv6Hx544AfwSjgjEjcnVAkLP7vWIcsIKnLOGyLFMVTIag2x4BM8l_KNiIzWV_DwdThN4TE3P6V7GTqB3fvbdvVp6s3HerWsTUvBXQzvucnBW8scRKWz2qSkmpOoJUa_QHIqGDhL5hQ6wqTW7ym0WdvryhOY33_b_lxK3-X42x-OTf8XCePNEAdDHAz8Dw5ANSA</recordid><startdate>20050612</startdate><enddate>20050612</enddate><creator>Luk, Chi-Keung</creator><creator>Cohn, Robert</creator><creator>Muth, Robert</creator><creator>Patil, Harish</creator><creator>Klauser, Artur</creator><creator>Lowney, Geoff</creator><creator>Wallace, Steven</creator><creator>Reddi, Vijay Janapa</creator><creator>Hazelwood, Kim</creator><scope>AAYXX</scope><scope>CITATION</scope></search><sort><creationdate>20050612</creationdate><title>Pin</title><author>Luk, Chi-Keung ; Cohn, Robert ; Muth, Robert ; Patil, Harish ; Klauser, Artur ; Lowney, Geoff ; Wallace, Steven ; Reddi, Vijay Janapa ; Hazelwood, Kim</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c195t-3b3af9822339464e26add66fd4621308701564093f4f3d9e10d628b19cf6c8703</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2005</creationdate><toplevel>online_resources</toplevel><creatorcontrib>Luk, Chi-Keung</creatorcontrib><creatorcontrib>Cohn, Robert</creatorcontrib><creatorcontrib>Muth, Robert</creatorcontrib><creatorcontrib>Patil, Harish</creatorcontrib><creatorcontrib>Klauser, Artur</creatorcontrib><creatorcontrib>Lowney, Geoff</creatorcontrib><creatorcontrib>Wallace, Steven</creatorcontrib><creatorcontrib>Reddi, Vijay Janapa</creatorcontrib><creatorcontrib>Hazelwood, Kim</creatorcontrib><collection>CrossRef</collection><jtitle>SIGPLAN notices</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Luk, Chi-Keung</au><au>Cohn, Robert</au><au>Muth, Robert</au><au>Patil, Harish</au><au>Klauser, Artur</au><au>Lowney, Geoff</au><au>Wallace, Steven</au><au>Reddi, Vijay Janapa</au><au>Hazelwood, Kim</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Pin: building customized program analysis tools with dynamic instrumentation</atitle><jtitle>SIGPLAN notices</jtitle><date>2005-06-12</date><risdate>2005</risdate><volume>40</volume><issue>6</issue><spage>190</spage><epage>200</epage><pages>190-200</pages><issn>0362-1340</issn><eissn>1558-1160</eissn><abstract>Robust and powerful software instrumentation tools are essential for program analysis tasks such as profiling, performance evaluation, and bug detection. To meet this need, we have developed a new instrumentation system called
Pin
. Our goals are to provide
easy-to-use, portable, transparent
, and
efficient
instrumentation. Instrumentation tools (called
Pintools
) are written in C/C++ using Pin's rich API. Pin follows the model of ATOM, allowing the tool writer to analyze an application at the instruction level without the need for detailed knowledge of the underlying instruction set. The API is designed to be
architecture independent
whenever possible, making Pintools source compatible across different architectures. However, a Pintool can access architecture-specific details when necessary. Instrumentation with Pin is mostly
transparent
as the application and Pintool observe the application's original, uninstrumented behavior. Pin uses
dynamic compilation
to instrument executables while they are running. For efficiency, Pin uses several techniques, including inlining, register re-allocation, liveness analysis, and instruction scheduling to optimize instrumentation. This fully automated approach delivers significantly better instrumentation performance than similar tools. For example, Pin is 3.3x faster than Valgrind and 2x faster than DynamoRIO for basic-block counting. To illustrate Pin's versatility, we describe two Pintools in daily use to analyze production software. Pin is publicly available for Linux platforms on four architectures: IA32 (32-bit x86), EM64T (64-bit x86), Itanium®, and ARM. In the ten months since Pin 2 was released in July 2004, there have been over 3000 downloads from its website.</abstract><doi>10.1145/1064978.1065034</doi><tpages>11</tpages></addata></record> |
fulltext | fulltext |
identifier | ISSN: 0362-1340 |
ispartof | SIGPLAN notices, 2005-06, Vol.40 (6), p.190-200 |
issn | 0362-1340 1558-1160 |
language | eng |
recordid | cdi_crossref_primary_10_1145_1064978_1065034 |
source | Access via ACM Digital Library |
title | Pin: building customized program analysis tools with dynamic instrumentation |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-24T03%3A44%3A58IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-crossref&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Pin:%20building%20customized%20program%20analysis%20tools%20with%20dynamic%20instrumentation&rft.jtitle=SIGPLAN%20notices&rft.au=Luk,%20Chi-Keung&rft.date=2005-06-12&rft.volume=40&rft.issue=6&rft.spage=190&rft.epage=200&rft.pages=190-200&rft.issn=0362-1340&rft.eissn=1558-1160&rft_id=info:doi/10.1145/1064978.1065034&rft_dat=%3Ccrossref%3E10_1145_1064978_1065034%3C/crossref%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true |