<html><head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8"></head><body><form method="POST">

<div id="maincontent">
<div id="midcolumn">
<h1>IP Log for tools.linuxtools</h1>

<h2>Licenses</h2>
	<ul>
			<li>Eclipse Public License v1.0</li>
		</ul>

<h2>Third-Party Code</h2>

<h3>Pre-Req Dependencies</h3>
<table border="1" cellpadding="3" cellspacing="0" width="100%">
<tbody><tr><th bgcolor="#7A79A7">CQ</th><th bgcolor="#7A79A7">Third-Party Code</th><th bgcolor="#7A79A7">License</th><th bgcolor="#7A79A7">Use</th></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3181" target="_blank">3181</a></td><td width="55%">SystemTapGui</td><td width="20%">Eclipse Public License</td><td width="20%"></td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3376" target="_blank">3376</a></td><td width="55%">Apache Commons Net Version: 2.0 (Subset) (using Orbit CQ3188)</td><td width="20%">Apache License, 2.0</td><td width="20%">unmodified source&nbsp;&amp;&nbsp;binary</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4305" target="_blank">4305</a></td><td width="55%">Glibc Documentation 2.7 Subset (Manual Directory Texi Files only Excluding Examples Folder)</td><td width="20%">GNU Free Documentation License version 1.1</td><td width="20%">modified source&nbsp;&amp;&nbsp;binary</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4742" target="_blank">4742</a></td><td width="55%">Apache Commons Net Version: 2.2</td><td width="20%">Apache License, 2.0</td><td width="20%">unmodified source&nbsp;&amp;&nbsp;binary</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4828" target="_blank">4828</a></td><td width="55%">libmatthew-java Version: 0.7.2</td><td width="20%">Expat License (MIT Style)</td><td width="20%">unmodified binary </td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=5928" target="_blank">5928</a></td><td width="55%">SWTChart Version: 0.7.0</td><td width="20%">Eclipse Public License</td><td width="20%">unmodified binary </td></tr>
</tbody></table>
<h3>Exempt Pre-Req and Works With Dependencies</h3>
<table border="1" cellpadding="3" cellspacing="0" width="100%">
<tbody><tr><th bgcolor="#7A79A7">CQ</th><th bgcolor="#7A79A7">Third-Party Code</th><th bgcolor="#7A79A7">License</th><th bgcolor="#7A79A7">Type</th></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2853" target="_blank">2853</a></td><td width="55%">Systemtap exempt third-party dependency Version: All</td><td width="20%">GNU General Public License (GPL)</td><td width="20%">exempt pre-req</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2965" target="_blank">2965</a></td><td width="55%">Linux Tools implied dependency:  rpm Version: 4.x</td><td width="20%">GPL v2</td><td width="20%">works with</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2966" target="_blank">2966</a></td><td width="55%">Linux Tools implied dependency:  rpmlint Version: any</td><td width="20%">GPL v2</td><td width="20%">works with</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2967" target="_blank">2967</a></td><td width="55%">Linux Tools implied dependency:  yum Version: any</td><td width="20%">GPL v2</td><td width="20%">works with</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2968" target="_blank">2968</a></td><td width="55%">Linux Tools implied dependency:  GNU Autotools Version: any</td><td width="20%">GPL v2</td><td width="20%">exempt pre-req</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3392" target="_blank">3392</a></td><td width="55%">lttng Version: all</td><td width="20%">GNU General Public License (GPL)</td><td width="20%">exempt pre-req</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3478" target="_blank">3478</a></td><td width="55%">systemtapguiserver Version: any</td><td width="20%">Eclipse Public License</td><td width="20%">works with</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3706" target="_blank">3706</a></td><td width="55%">binutils Version: any</td><td width="20%">GNU General Public License (GPL)</td><td width="20%">exempt pre-req</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3707" target="_blank">3707</a></td><td width="55%">liblttvtraceread Version: 0.12 � subset limited to LGPL licensed code</td><td width="20%">'Lesser' General Public License (LGPL) 2.1</td><td width="20%">exempt pre-req</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4857" target="_blank">4857</a></td><td width="55%">devhelp Version: N/A</td><td width="20%">Various</td><td width="20%">works with</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=5195" target="_blank">5195</a></td><td width="55%">policykit Version: 0.98 and up</td><td width="20%">GNU Library General Public License Version 2</td><td width="20%">works with</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=7705" target="_blank">7705</a></td><td width="55%">createrepo Version: 0.10</td><td width="20%">GNU General Public License (GPL) Version 2 or later versions</td><td width="20%">works with</td></tr>
</tbody></table>
<h3>Unused Approved Contributions</h3>
<table border="1" cellpadding="3" cellspacing="0" width="100%">
<tbody><tr><th bgcolor="#7A79A7">CQ</th><th bgcolor="#7A79A7">Third-Party Code</th><th bgcolor="#7A79A7">License</th><th bgcolor="#7A79A7">Status</th></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3065" target="_blank">3065</a></td><td width="55%">Apache Jakarta Commons Net Library Version: 1.4.1 (PB CQ230) (using Orbit CQ2105)</td><td width="20%">Apache License, 2.0</td><td width="20%">obsolete: was used in the past but is not longer used</td></tr>
<tr><td width="5%" align="right"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3066" target="_blank">3066</a></td><td width="55%">Apache Jakarta ORO Library Version: 2.0.8 (PB CQ232) (using Orbit CQ2104)</td><td width="20%">Apache Software License 1.1</td><td width="20%">obsolete: was used in the past but is not longer used</td></tr>
</tbody></table>
<h2>Committers</h2>


<table border="1" cellpadding="3" cellspacing="0">
<tbody><tr><th colspan="3" bgcolor="#7A79A7">Past and Present Active</th></tr>
<tr><th bgcolor="#7A79A7">Name</th>
<th bgcolor="#7A79A7">Organization</th>
<th bgcolor="#7A79A7">&nbsp;</th>
</tr>
<tr>
	<td>Chris Aniszczyk</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Elliott Baron</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Genevieve Bastien</td>
	<td>Ecole Polytechnique de Montreal </td>
		<td></td>
		</tr>
	<tr>
	<td>Nick Boldt</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>William Bourque</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Francois Chouinard</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Krzysztof Daniel</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Andrew Ferrazzutti</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Rodrigo Fraxino Araujo</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Severin Gehwolf</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Roland Grunberg</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Neil Guzman</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Daniel Henrique Barboza</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Bernd Hufmann</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Anithra P Janakiraman</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Jeff Johnston</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Matthew Khouzam</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Alexander Kurtakov</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Marc-Andre Laperle</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Rafael Medeiros Teixeira</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Alexandre Montplaisir</td>
	<td>Ecole Polytechnique de Montreal </td>
		<td></td>
		</tr>
	<tr>
	<td>Phil Muldoon</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Andrew Overholt</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Otavio Pontes</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Xavier Raynaud</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Alvaro Sanchez-Leon</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Patrick Tasse</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Niels Thykier</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Alphonse Van Assche</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Sami Wagiaalla</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Charley Wang</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	</tbody></table>
<p>


<table border="1" cellpadding="3" cellspacing="0">
<tbody><tr><th colspan="3" bgcolor="#7A79A7">Never Active</th></tr>
<tr><th bgcolor="#7A79A7">Name</th>
<th bgcolor="#7A79A7">Organization</th>
<th bgcolor="#7A79A7">&nbsp;</th>
</tr>
<tr>
		<td>Camilo Bernal</td>
		<td> </td>
				<td></td>
				</tr>
		<tr>
		<td>Wainer dos Santos Moschetta</td>
		<td>IBM </td>
				<td></td>
				</tr>
			</tbody></table>
	</p><p>
	</p><h2>Contributors and Their Contributions</h2>
<table border="1" cellpadding="3" cellspacing="0">
<tbody><tr>
<th bgcolor="#7A79A7">Ref</th>
<th bgcolor="#7A79A7">Size</th>
<th bgcolor="#7A79A7">Description</th>
</tr>
<tr><td colspan="3" style="background-color: #DDDDDD">rosaliam@linux.vnet.ibm.com</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/343025" target="_blank">343025</a></td>
		<td>2896 bytes</td>
		<td>Some of the event names in the OProfile profile configuration event tab are malformed<br>Attachment 195430: Correct Bug fix: 343025 - Event names in the OProfile are malformed</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">avkosinsky@yandex.ru</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/355385" target="_blank">355385</a></td>
		<td>2247 bytes</td>
		<td>Workaround ManParser problem for Windows/Cygwin<br>Attachment 201919: ManParser.java</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Aaron&nbsp;Luchko (luchko.ca)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/76882" target="_blank">76882</a></td>
		<td>7852 bytes</td>
		<td>RPM: Enhancement: automatically select current project in Export dialog<br>Attachment 15670: Patch for the enhancement</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/76882" target="_blank">76882</a></td>
		<td>910 bytes</td>
		<td>RPM: Enhancement: automatically select current project in Export dialog<br>Attachment 15756: changelog entry</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/78871" target="_blank">78871</a></td>
		<td>559 bytes</td>
		<td>Icon missing for oprofile launch<br>Attachment 15935: Adds icons/ to the build.properties</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82881" target="_blank">82881</a></td>
		<td>1775 bytes</td>
		<td>Combo box should contain list of previous rpms opened<br>Attachment 17177: a patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82881" target="_blank">82881</a></td>
		<td>627 bytes</td>
		<td>Combo box should contain list of previous rpms opened<br>Attachment 17178: changelog entry</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/83031" target="_blank">83031</a></td>
		<td>12199 bytes</td>
		<td>Fixing various naming problems in source<br>Attachment 17216: le patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/83135" target="_blank">83135</a></td>
		<td>11014 bytes</td>
		<td>Option to export as configured project<br>Attachment 17266: more patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/83150" target="_blank">83150</a></td>
		<td>1923 bytes</td>
		<td>[RPM} Incorrect path for diff<br>Attachment 17270: patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexander&nbsp;Kurtakov (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/207207" target="_blank">207207</a></td>
		<td>985 bytes</td>
		<td>Rpm editor do not accept valid values for Release:<br>Attachment 80976: Possible fix</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/214217" target="_blank">214217</a></td>
		<td>3624 bytes</td>
		<td>Source completion patch<br>Attachment 86091: Source completion </td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/214217" target="_blank">214217</a></td>
		<td>565 bytes</td>
		<td>Source completion patch<br>Attachment 86160: Changelog entry</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/215788" target="_blank">215788</a></td>
		<td>2729 bytes</td>
		<td>Support for adding directory to check for rpm macroses (e.g. /etc/rpm/macros.d)<br>Attachment 87255: The proposed patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/217316" target="_blank">217316</a></td>
		<td>11316 bytes</td>
		<td>[Patch]Add interface to add directories to Macro completion list<br>Attachment 88439: The patch containing the enhancement.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexandre&nbsp;Montplaisir (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b64b4e3caac38ab55a5fd20a8daed92e3ca5c74" target="_blank">3b64b4</a></td>
		<td>111 lines</td>
		<td>Add method to get attributes with a wildcard in the path</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5dea65a54b20bdf792e4a5a901e3bf67c9eac34f" target="_blank">5dea65</a></td>
		<td>31 lines</td>
		<td>Add unit tests for the new getQuarks() method</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e5945e9f37805b4e29b8873a736564a3359e5ac" target="_blank">7e5945</a></td>
		<td>43 lines</td>
		<td>Add option to retrieve sub-attributes recursively</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b3a1756d657675294e3e1eb4c0c458237f73271a" target="_blank">b3a175</a></td>
		<td>48 lines</td>
		<td>Expose the getSubAttributes() method through the StateSystem</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5698b3415b5c9682ec73eb50a2e433f6ea41c5b" target="_blank">e5698b</a></td>
		<td>7 lines</td>
		<td>Fix location of the new test trace file</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexandre&nbsp;Montplaisir (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09303135edb89fad4ac52f0e5fdfc1d67a4ccadb" target="_blank">093031</a></td>
		<td>4753 lines</td>
		<td>Merge Generic State System core part</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2a5a7d97e0bafd32cd85337e103a691db28e5cf9" target="_blank">2a5a7d</a></td>
		<td>145 lines</td>
		<td>Don't catch the FileNotFound exception in CTF tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44b4b425f21cd19c0a3480c393511ae8a3aca821" target="_blank">44b4b4</a></td>
		<td>13 lines</td>
		<td>Update the CTF tests to the previous change</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cc0a4c7e7e0f17b65f9ee96a7ae880f54e81f59" target="_blank">4cc0a4</a></td>
		<td>1280 lines</td>
		<td>Integrate CtfAdaptor package in TMF</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=512f28fdb0bdaaab2de9a034784c73a973e2af0e" target="_blank">512f28</a></td>
		<td>58 lines</td>
		<td>Start fixing GSS tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=563ee6fb6dc7e992a39f78d077edbf7ab4c0b555" target="_blank">563ee6</a></td>
		<td>92 lines</td>
		<td>Update State History construction tests to the newest test trace</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5d5902a323109ca9ef4510593f762b82d133613d" target="_blank">5d5902</a></td>
		<td>49 lines</td>
		<td>Restore extra checks in SequenceDefinition's constructor</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9901a4af877c6d74fe200597b175dd8bf6caecfb" target="_blank">9901a4</a></td>
		<td>9 lines</td>
		<td>Avoid printing the exception when CtfTmfTrace.validate() fails</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9c24c5ec351978e1ff45213a13a1594c877aff31" target="_blank">9c24c5</a></td>
		<td>45 lines</td>
		<td>GSS: Avoid doing time-range requests if one of the timestamps is invalid</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5bf72ca186cc78f842e637580b64a74c36f38c4" target="_blank">b5bf72</a></td>
		<td>43 lines</td>
		<td>Use ITmfEvent in a couple more places</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b714e56f44c8b93dd4c944c0c245b27fa880e1e8" target="_blank">b714e5</a></td>
		<td>1245 lines</td>
		<td>Merge Kernel state system input provider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f1be1c40b328402d3c3ce52ac381c5aee5ad1451" target="_blank">f1be1c</a></td>
		<td>15 lines</td>
		<td>Make the Kernel event handler tests work again</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexandre&nbsp;Montplaisir (voxpopuli.im)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/340700" target="_blank">340700</a></td>
		<td>1303 bytes</td>
		<td>[LTTng] File descriptors exhausted because traces are never closed<br>Attachment 191708: Proposed fix</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/370501" target="_blank">370501</a></td>
		<td>9104 bytes</td>
		<td>[TMF] Generic State System<br>Attachment 211523: Second part of the code contribution</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/375878" target="_blank">375878</a></td>
		<td>7796 bytes</td>
		<td>[TMF] State system attributes should allow only one type of value<br>Attachment 213471: proposed patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/376426" target="_blank">376426</a></td>
		<td>12930 bytes</td>
		<td>[TMF] Queries to the state system are not multi-thread safe<br>Attachment 213820: Proposed patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alphonse&nbsp;Van&nbsp;Assche (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/177220" target="_blank">177220</a></td>
		<td>108450 bytes</td>
		<td>Some patches for the specfile editor<br>Attachment 62662: foldind-hover-completions </td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181110" target="_blank">181110</a></td>
		<td>7680 bytes</td>
		<td>Should SpecfileReconcilingStrategy#updateEditor be empty?<br>Attachment 63345: Update the editor without saving the file</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181236" target="_blank">181236</a></td>
		<td>6531 bytes</td>
		<td>Write tests for new editor functionality (folding, hover, completion)<br>Attachment 63339: RpmMacroProposalsList and RpmPackageProposalsList test</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181245" target="_blank">181245</a></td>
		<td>19179 bytes</td>
		<td>[PATCH] RPM packages coloration and hover support<br>Attachment 63208: packages coloration, hover and completion support</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181395" target="_blank">181395</a></td>
		<td>803 bytes</td>
		<td>[PATCH] RpmMacroProposalsList replaceAll fix<br>Attachment 63165: fix replaceAll() another replaceAll() bug in RpmMacroProposalsList</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181747" target="_blank">181747</a></td>
		<td>6788 bytes</td>
		<td>Hyperlink with macro detector<br>Attachment 63351: URLHyperlinkWithMacroDetector</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/182302" target="_blank">182302</a></td>
		<td>4586 bytes</td>
		<td>[PATCH] some display fixes<br>Attachment 63719: some-display-fixes-on527</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/182302" target="_blank">182302</a></td>
		<td>1741 bytes</td>
		<td>[PATCH] some display fixes<br>Attachment 63817: Fix: package names as sub-names of other package names</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/182633" target="_blank">182633</a></td>
		<td>5832 bytes</td>
		<td>Add outline icons<br>Attachment 65388: Outline and completion icons</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/184955" target="_blank">184955</a></td>
		<td>30362 bytes</td>
		<td>[PATCH] specfile editor - macro occurences annotations<br>Attachment 65513: macro occurences annotations</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/185227" target="_blank">185227</a></td>
		<td>18007 bytes</td>
		<td>Specfile plugin - convert tab to spaces<br>Attachment 65693: convert tab by spaces</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alvaro&nbsp;Sanchez-Leon (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/290250" target="_blank">290250</a></td>
		<td>323705 bytes</td>
		<td>[LTTng] Integrate LTTng UI State Views (controlflow, resources and statistics)<br>Attachment 148098: patch uggraded to svn latest Sept 25 09</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/290968" target="_blank">290968</a></td>
		<td>62505 bytes</td>
		<td>[Lttng] Refactor state views to use common code to handle Data Requests + others<br>Attachment 148477: patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291097" target="_blank">291097</a></td>
		<td>86856 bytes</td>
		<td>[LTTng] Align process creation with C-code implementation<br>Attachment 149049: udpated to  HEAD</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291981" target="_blank">291981</a></td>
		<td>17713 bytes</td>
		<td>[LTTng] Switching between Experiments needs to clear old experiment data<br>Attachment 149308: Patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292393" target="_blank">292393</a></td>
		<td>30833 bytes</td>
		<td>[LTTng] Improve search of a process within the State model<br>Attachment 150826: re-created</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292397" target="_blank">292397</a></td>
		<td>29811 bytes</td>
		<td>[LTTng] Control Flow View - Improve the search of Local UI model Process<br>Attachment 150005: Patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/296266" target="_blank">296266</a></td>
		<td>1532 bytes</td>
		<td>[LTTng] Processes may be created without a valid traceID<br>Attachment 153199: patch - state processes shall always have a valid traceID</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/297086" target="_blank">297086</a></td>
		<td>853 bytes</td>
		<td>[LTTng] Resources view not showing all information<br>Attachment 153935: patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Andrew&nbsp;Ferrazzutti (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c7bf2973d55b93311e33e2d641c5880e4ef6dd7" target="_blank">0c7bf2</a></td>
		<td>40 lines</td>
		<td>Improvement to pie chart slice colours.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0fe6a0459f65cc3c4f355e3d0e37a8040799a4ab" target="_blank">0fe6a0</a></td>
		<td>7 lines</td>
		<td>Systemtap: perform line-by-line graph parsing.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=406129b693787e3feb796c8e0533ad01afdf3498" target="_blank">406129</a></td>
		<td>345 lines</td>
		<td>Implement improved UI for regex parsing of graph output.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7b8671a7e761e79c502daeab0babea9bfc1f0021" target="_blank">7b8671</a></td>
		<td>288 lines</td>
		<td>Systemtap: Prevent running scripts if existing graphs are missing required columns.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7fa2c8d7e05e5fcaad33667327d8f97ace73461b" target="_blank">7fa2c8</a></td>
		<td>230 lines</td>
		<td>Systemtap: make fixes to script start/stop actions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=93ea4bc60cf0eb8a2324e45304ef1eb9127eb678" target="_blank">93ea4b</a></td>
		<td>55 lines</td>
		<td>Systemtap: save new default Run Configurations.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4edf47058611ffceaa0d54e8023133db6316fa7" target="_blank">a4edf4</a></td>
		<td>108 lines</td>
		<td>Systemtap: Add Edit Graph button.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b7aabb7513857114d529b1a8bfdc6ed786709fa7" target="_blank">b7aabb</a></td>
		<td>50 lines</td>
		<td>Systemtap: Add Copy Graph button</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b991db9d4412be76a4e1f3f92a0701e1e1cb27cd" target="_blank">b991db</a></td>
		<td>1020 lines</td>
		<td>Systemtap: 1-page graph configuration wizard.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dbaf2af3f0fbcdd29f8a5e884b01636d89a1454c" target="_blank">dbaf2a</a></td>
		<td>108 lines</td>
		<td>Systemtap: Add Edit Graph button.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f6cf0d213bc791ca45b2e3b8f0c6c4d01375177f" target="_blank">f6cf0d</a></td>
		<td>152 lines</td>
		<td>Improvement to pie chart slice colours.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Andrew&nbsp;Robinson (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/353214" target="_blank">353214</a></td>
		<td>21555 bytes</td>
		<td>Modification of command running methods to allow process access.<br>Attachment 201431: Updated patch.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/363027" target="_blank">363027</a></td>
		<td>5261 bytes</td>
		<td>Please add license feature to eclipse-build<br>Attachment 208201: License feature patch.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/369578" target="_blank">369578</a></td>
		<td>2677 bytes</td>
		<td>Make eclipse-copy-platform use relative path.<br>Attachment 210014: The updated fix.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Anna&nbsp;Dushistova (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/382684" target="_blank">382684</a></td>
		<td>3506 bytes</td>
		<td>Allow reusing already defined connections that have Files and Shells subsystems<br>Attachment 217476: Hiding "local" system type connections</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/383047" target="_blank">383047</a></td>
		<td>3356 bytes</td>
		<td>NPE while importing a CTF trace<br>Attachment 217586: Patch that fixes the problem</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Ansgar&nbsp;Radermacher (cea.fr)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=426d6e3be569b9e9604f81b13741155622504a0f" target="_blank">426d6e</a></td>
		<td>102 lines</td>
		<td>tmf: Support the model URI of a trace event</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Benjamin&nbsp;Drung (debian.org)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ee1a5cafa0964ea151daddf8ef0e43869cff28c5" target="_blank">ee1a5c</a></td>
		<td>2 lines</td>
		<td>Support finding libjasper-java 5.5.33-1 or newer on Debian.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Benjamin&nbsp;Drung (ubuntu.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/280688" target="_blank">280688</a></td>
		<td>7637 bytes</td>
		<td>[eclipse-build] Ease usage of system-installed dependencies (JARs)<br>Attachment 160255: debian.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/280688" target="_blank">280688</a></td>
		<td>1617 bytes</td>
		<td>[eclipse-build] Ease usage of system-installed dependencies (JARs)<br>Attachment 160308: debian2.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/287719" target="_blank">287719</a></td>
		<td>952 bytes</td>
		<td>ant clean target<br>Attachment 145717: ant clean patch v2</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/287752" target="_blank">287752</a></td>
		<td>3569 bytes</td>
		<td>Please store the build log in files<br>Attachment 145727: output.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/287753" target="_blank">287753</a></td>
		<td>1939 bytes</td>
		<td>Adjust the Java home variable for building eclipse<br>Attachment 145728: java-path.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/287758" target="_blank">287758</a></td>
		<td>10552 bytes</td>
		<td>Please add /usr/lib/jvm/default-java as alternative Java directory<br>Attachment 145731: java-path.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/289938" target="_blank">289938</a></td>
		<td>1999 bytes</td>
		<td>install target<br>Attachment 147637: install-target.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/289939" target="_blank">289939</a></td>
		<td>2733 bytes</td>
		<td>missing stamp file for provision.sdk target<br>Attachment 147640: stamp-fix-v2.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291504" target="_blank">291504</a></td>
		<td>762 bytes</td>
		<td>link to eclipse-binary<br>Attachment 148911: eclipse-binary.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291681" target="_blank">291681</a></td>
		<td>995 bytes</td>
		<td>build Equinox Initializer<br>Attachment 149054: buildEquinoxInitializer.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292475" target="_blank">292475</a></td>
		<td>3604 bytes</td>
		<td>support tar-less design<br>Attachment 149836: support-extracted-source-v2.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292610" target="_blank">292610</a></td>
		<td>986 bytes</td>
		<td>correct perm after applying patch<br>Attachment 149814: fix-perm.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292610" target="_blank">292610</a></td>
		<td>824 bytes</td>
		<td>correct perm after applying patch<br>Attachment 149820: preserve-perms-on-install.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292611" target="_blank">292611</a></td>
		<td>1026 bytes</td>
		<td>Run bash scripts with bash and not with sh<br>Attachment 149817: bashisms.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292706" target="_blank">292706</a></td>
		<td>889 bytes</td>
		<td>eclipse-R3_5_1-fetched-src.tar.bz2 contains binaries<br>Attachment 150081: remove-binaries.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/294249" target="_blank">294249</a></td>
		<td>2138 bytes</td>
		<td>Please rename the version string in fetched source tarball name<br>Attachment 159845: version-string.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/295307" target="_blank">295307</a></td>
		<td>1265 bytes</td>
		<td>Remove version string from extracted eclipse tarball<br>Attachment 152357: remove-eclipse-version.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/295523" target="_blank">295523</a></td>
		<td>815 bytes</td>
		<td>Move config file to /etc<br>Attachment 153729: move-config-file-to-etc-v2.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/295525" target="_blank">295525</a></td>
		<td>918 bytes</td>
		<td>Correct the directory in eclipse.ini<br>Attachment 152536: fix-directory-in-eclipse-ini.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/303447" target="_blank">303447</a></td>
		<td>1848 bytes</td>
		<td>The SDK source contains binary files<br>Attachment 159847: buildSDKSource3.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/303447" target="_blank">303447</a></td>
		<td>501 bytes</td>
		<td>The SDK source contains binary files<br>Attachment 160335: more-cleanup.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/316525" target="_blank">316525</a></td>
		<td>419 bytes</td>
		<td>[eclipse-build] Please remove temporary files from SDK source<br>Attachment 171666: buildSDKSource.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/317370" target="_blank">317370</a></td>
		<td>1039 bytes</td>
		<td>[eclipse-build] [debian] Please update jetty dependency<br>Attachment 173435: dependency3.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/317372" target="_blank">317372</a></td>
		<td>1476 bytes</td>
		<td>[eclipse-build] [debian] e36-branch fails to build on Ubuntu<br>Attachment 172454: java-home.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/317391" target="_blank">317391</a></td>
		<td>2770 bytes</td>
		<td>[eclipse-build] [debian] Please determine build architecture in ant and not shell<br>Attachment 172994: build-arch.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/318577" target="_blank">318577</a></td>
		<td>29796 bytes</td>
		<td>[eclipse-build] [debian] Please refresh patches<br>Attachment 173195: refresh-patches.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319110" target="_blank">319110</a></td>
		<td>1144 bytes</td>
		<td>[eclipse-build] Remove logs on distclean<br>Attachment 174542: distclean-logs2.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319473" target="_blank">319473</a></td>
		<td>4613 bytes</td>
		<td>[eclipse-build] [debian] Extract the SWT libraries (.so files) after installation<br>Attachment 173952: generate-metadata-and-extract-swt-libraries2.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319473" target="_blank">319473</a></td>
		<td>1365 bytes</td>
		<td>[eclipse-build] [debian] Extract the SWT libraries (.so files) after installation<br>Attachment 173953: remove-unnecessary-files.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319474" target="_blank">319474</a></td>
		<td>1790 bytes</td>
		<td>[eclipse-build] [debian] Fix bashism in eclipse-pde.build-add-package-build.patch<br>Attachment 173957: fix-bashism.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319479" target="_blank">319479</a></td>
		<td>2429 bytes</td>
		<td>[eclipse-build] [debian] Please compile xpt<br>Attachment 173961: compile-xpt.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/358246" target="_blank">358246</a></td>
		<td>1145 bytes</td>
		<td>[eclipse-build] Support finding libjasper-java 5.5.33-1 or newer on Debian.<br>Attachment 203680: find-newer-system-jasper.patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Bernd&nbsp;Hufmann (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/316467" target="_blank">316467</a></td>
		<td>84326 bytes</td>
		<td>[LTTng] Histogram View short requests not coalesced with Control Flow View and Resources View<br>Attachment 181862: Improved Request Coalescing and other performance / usability improvements (helios)</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/316467" target="_blank">316467</a></td>
		<td>18412 bytes</td>
		<td>[LTTng] Histogram View short requests not coalesced with Control Flow View and Resources View<br>Attachment 181863: Improved Request Coalescing and other performance / usability improvements (indigo)</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/325661" target="_blank">325661</a></td>
		<td>116661 bytes</td>
		<td>[LTTng] Performance improvements<br>Attachment 183706: Statistics improvement and better tuning of background request splitting</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/327711" target="_blank">327711</a></td>
		<td>17727 bytes</td>
		<td>[LTTng] SWTException (widget is disposed) problem<br>Attachment 180825: patch for asyncExec problems</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/327711" target="_blank">327711</a></td>
		<td>18412 bytes</td>
		<td>[LTTng] SWTException (widget is disposed) problem<br>Attachment 180826: patch for asyncExec problems</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/329473" target="_blank">329473</a></td>
		<td>1127 bytes</td>
		<td>[LTTng] Experiment instability<br>Attachment 182508: update vertical scrollbar in CFV asynchronously to get correct display</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/329579" target="_blank">329579</a></td>
		<td>911 bytes</td>
		<td>[LTTng] NullPointerException when opening HistogramView<br>Attachment 182510: Fix for NullPointerException</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/329764" target="_blank">329764</a></td>
		<td>727 bytes</td>
		<td>[LTTng] NullPointerException when loading an Experiment<br>Attachment 182699: Fix for NullPointerException in LttngExperiment</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/331156" target="_blank">331156</a></td>
		<td>1954 bytes</td>
		<td>[LTTng] Memory leak when selecting an experiment<br>Attachment 183888: Fix for memory leak</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/331467" target="_blank">331467</a></td>
		<td>357234 bytes</td>
		<td>[LTTng] Add a latency analysis compoment<br>Attachment 209983: New version of latency analysis</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Camilo&nbsp;Bernal (voip-10-15-18-77.yyz.redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=36c6dc340a8fccfbd0e18e83abc9e468938256b7" target="_blank">36c6dc</a></td>
		<td>6 lines</td>
		<td>Implemented compare method for NameSorter class in PerfProfileView.java.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Camilo&nbsp;Bernal (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00848945764cf497e0e876cfe701ab431a2533a2" target="_blank">008489</a></td>
		<td>13 lines</td>
		<td>Add launch provider extension point to Callgraph.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0252e0d8dfcb40e1036c01bc0f5e6893ace40de4" target="_blank">0252e0</a></td>
		<td>28 lines</td>
		<td>Test perf stat elapsed time entry separately.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=03928e0c779f06d1eb8975e559b4a8b7bfe4bdce" target="_blank">03928e</a></td>
		<td>1 lines</td>
		<td>Add call to layout method to parent composite to resize all children components,</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=03dc5ef0317d0ba3b98746480a0e02da62c1f958" target="_blank">03dc5e</a></td>
		<td>512 lines</td>
		<td>Re-write of perf plug-in tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=03ec5ab9426ce7f6e32ee055c35d27dd61d192f1" target="_blank">03ec5a</a></td>
		<td>20 lines</td>
		<td>Provider plug-in: Validate tool specific tab configurations.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=04b4d62990bfda9b07542a3ee247fef8ec71b774" target="_blank">04b4d6</a></td>
		<td>106 lines</td>
		<td>Perf: Open stat data files in stat view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b2d9a5e9cc49dedcd00b1504f97ecd536140c8f" target="_blank">0b2d9a</a></td>
		<td>183 lines</td>
		<td>Assume stap is installed in tests dealing with stap processes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=100e4be5e9762493f06a975ba807187131557d72" target="_blank">100e4b</a></td>
		<td>396 lines</td>
		<td>Add support for perf diff command.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=122cb6c12aeadc6793da9e613fbc97d7cc850593" target="_blank">122cb6</a></td>
		<td>24 lines</td>
		<td>Systemtap: Make toggle comment command visible under 'Keys' preferences</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16d11c577f6d0cb82109b4068cf07aacf52fc2d8" target="_blank">16d11c</a></td>
		<td>20 lines</td>
		<td>Save most recent perf stat session under the working directory.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16edc98e51a9687cd05a3e0c6049bd383b53d06c" target="_blank">16edc9</a></td>
		<td>206 lines</td>
		<td>Extract opreport execution functionality in OpxmlRunner.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1757c7cb4e52f6cd2183617dbef45e0dc9f1be09" target="_blank">1757c7</a></td>
		<td>21 lines</td>
		<td>Add null check to PrintStream in PerfLaunchConfigurationDelegate.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=177a01b05b3ab190007b0b287f4bfc820fe5f638" target="_blank">177a01</a></td>
		<td>165 lines</td>
		<td>Clean up o.e.l.systemtap.ui.ide.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=18a2434af4445fba1ae6a95cbd2c9a01d6be2980" target="_blank">18a243</a></td>
		<td>122 lines</td>
		<td>Valgrind: Clear custom error markers after a build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=19e9bf1b29d5d70f18c21071f499b738f8dd0558" target="_blank">19e9bf</a></td>
		<td>8 lines</td>
		<td><a href="https://bugs.eclipse.org/402191" target="_blank">Bug 402191</a>: Fix for  Perf failing when obtaining source line numbers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1b5b4726aa48b6cfd4094636ca896b6018a5ed5e" target="_blank">1b5b47</a></td>
		<td>4 lines</td>
		<td>Perf: Do not wrap text in stat views.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c58fc257958485ca1a67c587074069142c8bb17" target="_blank">1c58fc</a></td>
		<td>50 lines</td>
		<td>Add name attribute to launch provider schema.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22fc65336632594d6ee4a2bca3014a5ec5c45bed" target="_blank">22fc65</a></td>
		<td>4 lines</td>
		<td>Use ProfileLaunchConfigurationTabGroup in callgraph's launch config tab group.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=239680f2a44bde772ae4d2ce216e3f73053dc65b" target="_blank">239680</a></td>
		<td>18 lines</td>
		<td><a href="https://bugs.eclipse.org/392685" target="_blank">Bug 392685</a>: Store unification profiling preferences in a single file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=23b1b5d8572888b1ec24b7cbfea3976fec3155d4" target="_blank">23b1b5</a></td>
		<td>117 lines</td>
		<td><a href="https://bugs.eclipse.org/392790" target="_blank">Bug 392790</a>: Prompt user to create a new launch configuration.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24c6de80d252339b51b2ab11a093d34d91f1d91f" target="_blank">24c6de</a></td>
		<td>112 lines</td>
		<td>Profiling type launch shortcuts should call provider's launch shortcut.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24f412afc04907dd92853755e78822f37e53c279" target="_blank">24f412</a></td>
		<td>78 lines</td>
		<td>Collapse if statements where possible in callgraph plug-ins.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=28fe095aa286844bc0cc045a909bd88e569f3720" target="_blank">28fe09</a></td>
		<td>36 lines</td>
		<td>Increase major version for plug-ins with recent api-breaking changes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=295b6fb8f5622c0f2cb816981594aefb3e3dcf27" target="_blank">295b6f</a></td>
		<td>110 lines</td>
		<td>Clean up and fix various warnings in PerfCore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c65fb2c7ab7564db96db97e0c006070cd06f534" target="_blank">2c65fb</a></td>
		<td>16 lines</td>
		<td>Systemtap: Add remaining @since tags to resolve API problems.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d44c904b18acec1a8dc54b859cbc8314f226521" target="_blank">2d44c9</a></td>
		<td>5 lines</td>
		<td><a href="https://bugs.eclipse.org/392788" target="_blank">Bug 392788</a>:  Move profiling preferences page under C/C++ preferences page.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d657e85ca761337a7d4b089d31c938ce04d57b4" target="_blank">2d657e</a></td>
		<td>29 lines</td>
		<td>Fix perf launch tests failures when perf is not available.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=32d88f8edfe086bc3f1a755aedda6917a9964fa7" target="_blank">32d88f</a></td>
		<td>18 lines</td>
		<td>Apply plug-in specific shortcut attributes only when launching shorcuts.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=35f4b3945cbee8659339a785ddd81b938821508d" target="_blank">35f4b3</a></td>
		<td>508 lines</td>
		<td>Add support for saving perf stat sessions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3627d231c8ee4606c1dc1726b82797513b71edfc" target="_blank">3627d2</a></td>
		<td>16 lines</td>
		<td>Add pre-generated data for used in helgrind tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=37de6ed7c1a3bc499bee6f63b304af3717499173" target="_blank">37de6e</a></td>
		<td>188 lines</td>
		<td>Add save session menu action to Perf view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a0958c93c0fb85880bca7b6164d5ba1bf5cbf4b" target="_blank">3a0958</a></td>
		<td>4 lines</td>
		<td>Bump up profiling.ui version due to recent changes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a4e285b915e2a1d4c7a6f39eba8def33b0f21d9" target="_blank">3a4e28</a></td>
		<td>88 lines</td>
		<td>Add default attribute to launch provider schema.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b2524ce605e0a747c29c5b0e73d6b088096ad95" target="_blank">3b2524</a></td>
		<td>10 lines</td>
		<td><a href="https://bugs.eclipse.org/393593" target="_blank">Bug 393593</a>: Combine flags for running the oprofile binary dependent tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e564354f1b90c59959979e20aa8134a161d7d73" target="_blank">3e5643</a></td>
		<td>12 lines</td>
		<td>Avoid passing null to StatData contructor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e69e199ccf288d8a55d6037ec7e9df068c8d214" target="_blank">3e69e1</a></td>
		<td>1927 lines</td>
		<td>Move handling of profile type plug-ins to the provider plug-in.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3fdf5ccbeca5c39752787289e8d5134e81203479" target="_blank">3fdf5c</a></td>
		<td>843 lines</td>
		<td>Clean up o.e.l.callgraph and o.e.l.systemtap.ui.*</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=406a96d7c2e633635a6af9391ce9ef48ea4c62ed" target="_blank">406a96</a></td>
		<td>16 lines</td>
		<td>Always set the plug-in working directory during a perf launch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=41125382489fd3ec8c2ecd3ac193999d36973e60" target="_blank">411253</a></td>
		<td>2 lines</td>
		<td>Perf: Fix class cast exception thrown when running StatComparisonViewTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=425a5378c2c00e2ee58b86d97b28d81738f61530" target="_blank">425a53</a></td>
		<td>63 lines</td>
		<td>Fix some warnings and remove unused method.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=487e9e85b04e8344d90edb6ec6d3b51b1661b79f" target="_blank">487e9e</a></td>
		<td>10 lines</td>
		<td>Add license header to SystemtapTest.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4aa78cdfefebdfc4a6c17df1fb76c7421a914dd1" target="_blank">4aa78c</a></td>
		<td>43 lines</td>
		<td><a href="https://bugs.eclipse.org/396505" target="_blank">Bug 396505</a>: Open Error Dialog when stap script name is of improper form.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4c7fa4cc4764d21ad1cbe77bd6eb15c80ec0b8d2" target="_blank">4c7fa4</a></td>
		<td>30 lines</td>
		<td>Valgrind: Add minimum version check to RUN_VALGRIND tests flag.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4d85f3e2fc95fc9b17f41c67a0b24007ef10843c" target="_blank">4d85f3</a></td>
		<td>538 lines</td>
		<td>Systemtap: Add toggle comment command to IDE</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f8a90c452b0dca690e29a8a2569b7321d47fb2d" target="_blank">4f8a90</a></td>
		<td>4 lines</td>
		<td>Perf: Add missing JUnit 4 test annotations.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=54f9dc9d9c7852db71bb3f9d58fa0f6c30a149a0" target="_blank">54f9dc</a></td>
		<td>3 lines</td>
		<td>Perf: Minor fix for stat comparison test.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=550f3906bf2f21eee44a8fc856977a1539be924b" target="_blank">550f39</a></td>
		<td>238 lines</td>
		<td>GCov: Remove ContextMenuHelper</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=559a9fede192a24e56bf4b9f99d69f67857f6081" target="_blank">559a9f</a></td>
		<td>288 lines</td>
		<td>Support events selection for perf stat.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=56b1bdce7254585b74437383fbff16dffae3c5a8" target="_blank">56b1bd</a></td>
		<td>403 lines</td>
		<td>Fix oprofile launch tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58076fc211c0bc5830ecbc22e51c01904491eb5a" target="_blank">58076f</a></td>
		<td>1071 lines</td>
		<td>Systemtap: Initial clean up of sonar warnings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a1e56f041f4b83cea160ef2141b926be0a2042d" target="_blank">5a1e56</a></td>
		<td>2 lines</td>
		<td>Change packaging type of o.e.l.perf.tests pom.xml to eclipse-test-plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5b764a7ac7d944eb92d7d94d549c63489165b835" target="_blank">5b764a</a></td>
		<td>21 lines</td>
		<td>Systemtap: Minor clean up of toggle comment handler and test.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e994ef69ed32541134d691d3ad458730c3319a3" target="_blank">5e994e</a></td>
		<td>23 lines</td>
		<td>Valgrind: Synchronize documentatin with wiki</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ff9c04695c4c33ca1720439abe86450f4f4b3f6" target="_blank">5ff9c0</a></td>
		<td>2 lines</td>
		<td>Enable oprofile ui tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=60be5ab5b5c7a27b8a8a4d96f86ef3e84fdac16b" target="_blank">60be5a</a></td>
		<td>106 lines</td>
		<td><a href="https://bugs.eclipse.org/393811" target="_blank">Bug 393811</a>: Prompt user on configuration creation when no config is available.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=65265f5cc6efdb99304698f11690eb387b9bffec" target="_blank">65265f</a></td>
		<td>16 lines</td>
		<td>Systemtap: Add remaining @since tags to resolve API problems.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6593e16b8c5ef4774a6327fea867ac9fd0af1fc0" target="_blank">6593e1</a></td>
		<td>107 lines</td>
		<td>Added ability to open perf data files in the Perf Viewer.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=68ce0e2063e5e5a9a806b74083a6b7e6004edd54" target="_blank">68ce0e</a></td>
		<td>16 lines</td>
		<td>Add pre-generated data for used in helgrind tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6b03d1e37a77dc856b458fb088ebf715bb14fb99" target="_blank">6b03d1</a></td>
		<td>3 lines</td>
		<td>fix for <a href="https://bugs.eclipse.org/349882" target="_blank">Bug 349882</a> - Call Graph tab shows name underlined.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6b19fbd7695ae430db3dcd23110a19dc4e53b22e" target="_blank">6b19fb</a></td>
		<td>134 lines</td>
		<td>Add tests for uncovered PerfCore functionality.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6b7abfb6b91322b52a5c280f9785fff36e762236" target="_blank">6b7abf</a></td>
		<td>4 lines</td>
		<td>Fix npe thrown during auto-completion of invalid probes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6c350dc39846aa12e3d9d6424739de434f29b352" target="_blank">6c350d</a></td>
		<td>11 lines</td>
		<td>Create perf save session command extension.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6ca693128a159f516a8e3676e20c4df4cc0c6e6c" target="_blank">6ca693</a></td>
		<td>31 lines</td>
		<td>Fix NPE in metadata singleton</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d5945d987cdbd06b887b1cd35c64b629a6e979e" target="_blank">6d5945</a></td>
		<td>63 lines</td>
		<td>Dataviewers: Externalize strings and add missing NLS tags.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=713b79f7738cffda58dd99684231676fccdd9d9f" target="_blank">713b79</a></td>
		<td>39 lines</td>
		<td><a href="https://bugs.eclipse.org/410367" target="_blank">Bug 410367</a>: Add missing 'about.html' page to source bundles.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7307726ed6d925d63b74639d08b58cfb2c13a9f9" target="_blank">730772</a></td>
		<td>113 lines</td>
		<td>Add support for quick perf stat session comparison.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=756c7d1a765fdc6bc314ae13378d94fe9ff1fd22" target="_blank">756c7d</a></td>
		<td>118 lines</td>
		<td>Revert "Profiling type launch shortcuts should call provider's launch shortcut."</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=75b5354362c3eefe0253dac61e308b2b94071237" target="_blank">75b535</a></td>
		<td>40 lines</td>
		<td>Oprofile: Synchronize documentation with wiki</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=76e202d071d18f2bd5234bfa331a8917c41d9369" target="_blank">76e202</a></td>
		<td>2 lines</td>
		<td>Perf: Add handler for global find action on the source disassembly view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=789be6cd4278a4e829f6669e1460608cd390aac4" target="_blank">789be6</a></td>
		<td>41 lines</td>
		<td>Perf: Log exceptions during the different parsing stages.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a6f715f4a2730a82c6eb404788721525a1a1b64" target="_blank">7a6f71</a></td>
		<td>621 lines</td>
		<td>Perf:Add stat diff view toolbar actions to switch between compared data</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=813ada6317130d3a5b24d68211b39b2a05d6c78d" target="_blank">813ada</a></td>
		<td>26 lines</td>
		<td>Perf: Synchronize documentation with wiki user guide.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=836354a817a2d075eed9b30a6fcec7401521fbf0" target="_blank">836354</a></td>
		<td>1176 lines</td>
		<td>Add support for comparing perf stat sessions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8b40b412f860c2d2d74cc2dad0a2d9dfed2f8655" target="_blank">8b40b4</a></td>
		<td>12 lines</td>
		<td>Log caught exceptions as opposed to printing them.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8ea9dcf8a28f570eb67754749bef09f0cfc78dde" target="_blank">8ea9dc</a></td>
		<td>63 lines</td>
		<td>Add priority attribute to launch provider schema.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8eef8cb5317c001115b4d509d8520a670081475a" target="_blank">8eef8c</a></td>
		<td>9 lines</td>
		<td>Remove path to perf check in PerfOptionsTab.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8fed7f98276560655938868d934cb9c329b57969" target="_blank">8fed7f</a></td>
		<td>494 lines</td>
		<td>Test profiling provider preferences page.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=921ba37d95cfec4654ec6abdabfb8ef9bfe2e10f" target="_blank">921ba3</a></td>
		<td>157 lines</td>
		<td>Improve assertions in Valgrind test plug-ins.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=938a1f6e8e2fc063ebdc5114c70bda53346987d1" target="_blank">938a1f</a></td>
		<td>4 lines</td>
		<td>Skip opcontrol status check in oprofile launch tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=964f7901fe1c1c259e8988b3d7aebe5321ff0156" target="_blank">964f79</a></td>
		<td>2050 lines</td>
		<td>Separate opcontrol and ui functionality in oprofile's event config tab.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9875e35da0eb88a4add3684d5ef1f6027e6bf308" target="_blank">9875e3</a></td>
		<td>2 lines</td>
		<td>Add null check to result of getting highest priority provider id.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9a4d05c6b9e961698d972a40ee9c82e75f5b9560" target="_blank">9a4d05</a></td>
		<td>504 lines</td>
		<td>Refactor snapshot launch provider plug-in to use provider plug-in.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ca079005d325260f87c5e01d49d01e3609a6ab6" target="_blank">9ca079</a></td>
		<td>394 lines</td>
		<td>Cleanup o.e.l.systemtap.ui.ide.structures.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f40a27a0627f4714b26a75d5a6138fc8408826f" target="_blank">9f40a2</a></td>
		<td>3 lines</td>
		<td>Fix oprofile testEventConfigTab test failure.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4716e6c3c5a14a0417e52c7068b7ef3aa5b4e14" target="_blank">a4716e</a></td>
		<td>1 lines</td>
		<td>Specify name attribute for perf launch provider extension.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a5c4686c77de264ae98f9be19de48aa74942721e" target="_blank">a5c468</a></td>
		<td>134 lines</td>
		<td>Add tests for annotation functionality in PerfCore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a93bb3b8f6b7e0d8c578ff84cd0df08c1a65fef7" target="_blank">a93bb3</a></td>
		<td>16 lines</td>
		<td>Make helgrind pre-generated test data reflect test source.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a94daf69e56141a74aa9e1a5ff391aaa812111e3" target="_blank">a94daf</a></td>
		<td>80 lines</td>
		<td>Perf: Introduce IPerfData interface to represent general perf data.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aae102f60cf1d64f5071a9bbea5ddb4fa9af8276" target="_blank">aae102</a></td>
		<td>19 lines</td>
		<td>Perf: Remove o.e.l.perf.tests.runPerf maven flag from parent pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=acfd3a49fa186e514a5b9e2ecbca80a91c37ab55" target="_blank">acfd3a</a></td>
		<td>1 lines</td>
		<td>Fix configuration update issue.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af7f7c510fc3a16e1990415c424f2344f85b6f67" target="_blank">af7f7c</a></td>
		<td>484 lines</td>
		<td>Move launchProvider extension access methods to ProviderFramework.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b4641e3580ffc0818167ea021c3030b242a4a0d4" target="_blank">b4641e</a></td>
		<td>120 lines</td>
		<td>Incorporate name of backend tool with provider launch configuration name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b89d98b6fe38fb1b881d4a4ad224a9ba712298ff" target="_blank">b89d98</a></td>
		<td>45 lines</td>
		<td>Improve documentation for launch provider extensions point.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b92871d45641e5b98991966cf3c7813e414d919a" target="_blank">b92871</a></td>
		<td>3 lines</td>
		<td>Add dependency needed for the launch shortcut extension point.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba457a0ee5121af9aeb68ec1b690fd8137ee9a11" target="_blank">ba457a</a></td>
		<td>37 lines</td>
		<td>Callgraph: Synchronize documentation with wiki</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bccf1d0668cf9d7404528449c9e1ddb8398578a8" target="_blank">bccf1d</a></td>
		<td>99 lines</td>
		<td>Add delegate attribute to launch provider.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bdf8a3b817f8d5ffbc64a49454040451a3fecd7a" target="_blank">bdf8a3</a></td>
		<td>3 lines</td>
		<td>GCov: Remove '==' in string comparison</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf5ddb628595280f13ac4f05e0122ac7f2ea0b5d" target="_blank">bf5ddb</a></td>
		<td>3 lines</td>
		<td>Add test for remaining uncovered ProviderFramework method.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0baa6628beb9e2e0b76ae5fb800540a97c6b286" target="_blank">c0baa6</a></td>
		<td>9 lines</td>
		<td><a href="https://bugs.eclipse.org/401638" target="_blank">Bug 401638</a> - Fix missing function tag error on valid gcda file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c86ec565724aa283ff0f5d3779131213ec0d5a97" target="_blank">c86ec5</a></td>
		<td>165 lines</td>
		<td>Remove ContextMenuHelper from PreferencesTest.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c8c54cd6f9c13a78c42c8263e3a01c10dbb68190" target="_blank">c8c54c</a></td>
		<td>27 lines</td>
		<td>Remove check when creating control for Oprofile/Perf event tabs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cae48a22e30a260e964a44c89b977417474032ab" target="_blank">cae48a</a></td>
		<td>135 lines</td>
		<td>Perf: Add tests for the source diassembly view's search functionality</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cdb18425ed27d47484727ea4d27a9853806a5d46" target="_blank">cdb184</a></td>
		<td>171 lines</td>
		<td>Perf: Refactoring of data manipulation logic</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ceb7b1cd92518d6f342c31e5f819514f462999ad" target="_blank">ceb7b1</a></td>
		<td>106 lines</td>
		<td><a href="https://bugs.eclipse.org/393811" target="_blank">Bug 393811</a>: Prompt user on configuration creation when no config is available.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ceb8a7d83741118d42363a7747c1666d3b996523" target="_blank">ceb8a7</a></td>
		<td>225 lines</td>
		<td>Refactor PerfLaunchConfigDelegate</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1f5ba78160d4bd6f069832b85f15611bd09dd09" target="_blank">d1f5ba</a></td>
		<td>455 lines</td>
		<td>Add launch provider to support time profiling plug-ins.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d43ed1956e29c71c6d6572b3ad64f310cd84a5ec" target="_blank">d43ed1</a></td>
		<td>91 lines</td>
		<td>Perf: Support text search for disassembly view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4ddc8225334a2d1183f33d61405b1860c34b59f" target="_blank">d4ddc8</a></td>
		<td>5 lines</td>
		<td>Perf: Save session tests should fail if test files cannot be deleted</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d69ce50b5e5aa7888d95cfc7fb3b53986353d8ef" target="_blank">d69ce5</a></td>
		<td>736 lines</td>
		<td>Move handlers from o.e.l.internal.perf.ui to their own package.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d871a1ec508061697044f254182981a27e1ac388" target="_blank">d871a1</a></td>
		<td>253 lines</td>
		<td>Add preselection of launch provider backend to launch provider's config tab.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9031a8e7edef26639fea83060d2ff895f17185f" target="_blank">d9031a</a></td>
		<td>1629 lines</td>
		<td>Add SWTBot test plug-in for testing Perf views.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9859dd9e887f70f0ee073e402a20c10ababd03a" target="_blank">d9859d</a></td>
		<td>2 lines</td>
		<td>Remove activator attributes from launch providers.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dbdd5f7ef802da99546dc60e9be2feb873be7543" target="_blank">dbdd5f</a></td>
		<td>122 lines</td>
		<td>Add preferences page to launch provider.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de0f3c227d8001e68a3301b0d209e42b96d7b571" target="_blank">de0f3c</a></td>
		<td>14 lines</td>
		<td>Added launch provider for perf.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfeca491c8b1d3f8466fdadf3b92e0807944c284" target="_blank">dfeca4</a></td>
		<td>10 lines</td>
		<td>Perf: Include event modifiers when matching perf stat event strings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e252684d28aa69772e6e25af850c561375652ed7" target="_blank">e25268</a></td>
		<td>43 lines</td>
		<td>Oprofile: Remove o.e.l.oprofile.*.runOprofile flags from pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e3a7610438e56c30323c76de826b801709c996a3" target="_blank">e3a761</a></td>
		<td>109 lines</td>
		<td><a href="https://bugs.eclipse.org/395401" target="_blank">Bug 395401</a>: Place Linux Tools short-cuts into special context menu item.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e47e24661ae0c5e345eadeeb2e1d396b1acd203e" target="_blank">e47e24</a></td>
		<td>3 lines</td>
		<td>Add layout data properties to launch provider's tab group.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eaec0980a20b254dfc843db413daa4810ea6be6c" target="_blank">eaec09</a></td>
		<td>6 lines</td>
		<td>Remove uneeded dependencies from Oprofile and Perf.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ece39a869c46447031b043ba2a8998a1f73ef2ed" target="_blank">ece39a</a></td>
		<td>171 lines</td>
		<td>Add tool tip and descriptive information to field editors in preferences window.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed87d6026e38993a4dc5a922eabd5a2e0187a557" target="_blank">ed87d6</a></td>
		<td>114 lines</td>
		<td>Callgraph: Fix various warnings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef2c2aba3eef34d7cdfb6087506e06bdf7c99caa" target="_blank">ef2c2a</a></td>
		<td>11 lines</td>
		<td>(<a href="https://bugs.eclipse.org/387314" target="_blank">Bug 387314</a>) Fix exception thrown when creating config with no project.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f2ef3bddf6e71e5681177de8b07fd052b91d6ed1" target="_blank">f2ef3b</a></td>
		<td>42 lines</td>
		<td>Further refactoring of PerfCore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f426f0a28a795e45a71888240819b8530b4facf0" target="_blank">f426f0</a></td>
		<td>9 lines</td>
		<td><a href="https://bugs.eclipse.org/401638" target="_blank">Bug 401638</a> - Fix missing function tag error on valid gcda file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f4ce880b10d1859e7e4dbd4634fa6f1746e013dc" target="_blank">f4ce88</a></td>
		<td>13 lines</td>
		<td>Make sure a launch provider exists for a plug-in when using a plug-in id.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f76f4f3b3fdba19a9c31de63078c97577348dab6" target="_blank">f76f4f</a></td>
		<td>16 lines</td>
		<td>Add launch provider to oprofile.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fe3cc4a170ce702116b43a6f01a9ba6ff456879a" target="_blank">fe3cc4</a></td>
		<td>2 lines</td>
		<td>Systemtap IDE: Treat any white space character as a token delimeter</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=feb5808e24a379199b7d3a60172bda59870b0fb8" target="_blank">feb580</a></td>
		<td>27 lines</td>
		<td><a href="https://bugs.eclipse.org/392787" target="_blank">Bug 392787</a>:  Add icons to the provider plug-in launch shortcuts.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ffab3beb832279e43d72a8190ae2216b6a76f1be" target="_blank">ffab3b</a></td>
		<td>711 lines</td>
		<td>Refactor launch provider to allow other plug-ins to extend its functionality.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/379447" target="_blank">379447</a></td>
		<td>1903 bytes</td>
		<td>Percentage elements should be displayed in sorted order<br>Attachment 216059: Implemented NameSorter compare method : PerfProfileView.java</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/379449" target="_blank">379449</a></td>
		<td>8988 bytes</td>
		<td>Perf data files should open into the Perf View<br>Attachment 216478: Patch resubmission for opening perf data files.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/382291" target="_blank">382291</a></td>
		<td>66742 bytes</td>
		<td>Perf plug-in tests should be re-written to be less machine dependent<br>Attachment 217243: Patch resubmission</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/383680" target="_blank">383680</a></td>
		<td>4773 bytes</td>
		<td>[unifyprofiling] Provide ability to set default plug-ins contributing under "Profile As" categories<br>Attachment 218051: Updated patch to reflect current changes on master.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/384196" target="_blank">384196</a></td>
		<td>2169 bytes</td>
		<td>Opening perf data files results in null argument error<br>Attachment 218232: Properly set configuration's project name</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Charley&nbsp;Wang (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f5ed5563795f387f22c25c3a1d3146569aa74c9f" target="_blank">f5ed55</a></td>
		<td>20 lines</td>
		<td>Fix BZ #316609.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Chris&nbsp;Aniszczyk (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4208347aea3d0438372d2b3491837be3aa13c93" target="_blank">c42083</a></td>
		<td>52 lines</td>
		<td>Add repo generation for the man module</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/326597" target="_blank">326597</a></td>
		<td>2596 bytes</td>
		<td>[eclipse-build] move to up Eclipse 3.6.1<br>Attachment 180002: eclipse-build.patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Christopher&nbsp;Daniel (pl.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ae6a179b8cb6dbb8ef4f28beb43cbcfee831970a" target="_blank">ae6a17</a></td>
		<td>19 lines</td>
		<td>Apply patch from #350304.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Corey&nbsp;Ashford (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0616ff686e4dc70af38d70543b7bf98a7a3bb460" target="_blank">0616ff</a></td>
		<td>2 lines</td>
		<td>linuxtools, oprofile: Improve error message when opcontrol returns a non-zero error code</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=32911ffcb217e7b3ad4b91b35cca8c361bfa20a9" target="_blank">32911f</a></td>
		<td>64 lines</td>
		<td>Fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=369468</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=34261b6fa2feef3f91c35df503521eabf1317982" target="_blank">34261b</a></td>
		<td>1268 lines</td>
		<td>Add new implementation of CMainTab using ResourceSelectorWidget</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=592a9da0fbdc42c6c7d0dad561c19af5080dd511" target="_blank">592a9d</a></td>
		<td>1175 lines</td>
		<td>Add ResourceSelectorWidget to be used to construct Remote launch configs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e17e752d40205a6a96d9a6b9e6d82d9ce4e0e9d" target="_blank">7e17e7</a></td>
		<td>116 lines</td>
		<td>Add ability to create the proxy using a URI in addition to an IProject</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8ed47c6da14a8ba3f6f996b11b7137e7c66c1b1a" target="_blank">8ed47c</a></td>
		<td>422 lines</td>
		<td>Reimplement the RemoteConnection class in terms of the RemoteProxy</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99a2ea3eb8585630e08cae96cc95c04b9fe912d6" target="_blank">99a2ea</a></td>
		<td>2 lines</td>
		<td>linuxtools, oprofile: Improve error message when opcontrol returns a non-zero error code</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef94e264aff532516aa8a9874ec8cbea27d4c3bb" target="_blank">ef94e2</a></td>
		<td>559 lines</td>
		<td>Add Valgrind Remote Tab Group that uses RemoteProxyCMainTab</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0eb69e75cabc00e154f308e8819b6b69fc18048" target="_blank">f0eb69</a></td>
		<td>116 lines</td>
		<td>Add ability to create the proxy using a URI in addition to an IProject</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Corey&nbsp;J&nbsp;Ashford (us.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c238cc92a617cec7f9c7169990c668827f1645b" target="_blank">2c238c</a></td>
		<td>21 lines</td>
		<td>Fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=369765</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/341292" target="_blank">341292</a></td>
		<td>2586 bytes</td>
		<td>Error message when opcontrol script returns an error needs improvement<br>Attachment 192210: Improves error message when opcontrol returns a non-zero status</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/342880" target="_blank">342880</a></td>
		<td>710 bytes</td>
		<td>Running install-noconsolehelper.sh after running install.sh causes corruption of /usr/bin/consolehelper<br>Attachment 193303: Patch to remove pre-existing ./opcontrol link/file</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/342883" target="_blank">342883</a></td>
		<td>569 bytes</td>
		<td>OProfile plug-in uses /usr/bin/consolehelper when available, but needs /usr/bin/consolehelper-gtk  as well<br>Attachment 193316: require /usr/bin/consolehelper-gtk is installed in install.sh</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/349720" target="_blank">349720</a></td>
		<td>210560 bytes</td>
		<td>SystemTap Help formatting doesn't conform to the rest of the Eclipse Help.<br>Attachment 198208: Cleans up existing SystemTap docs in place</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/351368" target="_blank">351368</a></td>
		<td>6434 bytes</td>
		<td>Error handling of opcontrol needs improvement<br>Attachment 199204: Patch to improve error handling of opcontrol</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/369765" target="_blank">369765</a></td>
		<td>2434 bytes</td>
		<td>RDTFileProxy needs improved error handling when a URL contains a bad connection id<br>Attachment 210094: Patch that improves error handling of URLs containing bad connection ids</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/369766" target="_blank">369766</a></td>
		<td>50654 bytes</td>
		<td>Request to add a IRemoteFileProxy based file and directory chooser for use in launch configuration tabs<br>Attachment 210419: Add ResourceSelectorWidget patch (version 2)</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/369875" target="_blank">369875</a></td>
		<td>19447 bytes</td>
		<td>Reimplement org.eclipse.linuxtools.profiling.launch.remote.RemoteConnection in terms of the IRemote* interfaces<br>Attachment
 210420: Patch to reimplement RemoteConnection in terms of the IRemote* 
classes and move it it to its parent class, version 2</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;Henrique&nbsp;Barboza (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0422f9168aba49e775c9d94684da36dcbd0da5e1" target="_blank">0422f9</a></td>
		<td>46 lines</td>
		<td>Perf plug-in: added end of process messages.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51f487f195686d420151d236fa13253bb1b33683" target="_blank">51f487</a></td>
		<td>7577 lines</td>
		<td>danielhb@br.ibm.com: Contributing Helgrind tests plug-in.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b392cc0ff192033391f2edfc90c729ae2132668b" target="_blank">b392cc</a></td>
		<td>11 lines</td>
		<td>Removing the -U flag of the Perf plug-in launch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bbad9cb2d4b95fe1eb80635380fb6ddae4021b27" target="_blank">bbad9c</a></td>
		<td>214 lines</td>
		<td>Adding pom.xml files to enable Perf build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c03a563c4b1042774c28d1a8cf910329d4309a7d" target="_blank">c03a56</a></td>
		<td>84 lines</td>
		<td>Fixing Helgrind tests plugin issue with Tycho.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cca821e50f99a47d400ab5d03d0d349d6f71126a" target="_blank">cca821</a></td>
		<td>4490 lines</td>
		<td>Helgrind.tests plug-in cleanup.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cdd81a6ee600ef97e14fa191743415ea6457f576" target="_blank">cdd81a</a></td>
		<td>7577 lines</td>
		<td>danielhb@br.ibm.com: Contributing Helgrind tests plug-in.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d94bf7de749e400a420d18aacdf2a96661d6e61a" target="_blank">d94bf7</a></td>
		<td>19 lines</td>
		<td>Fixing <a href="https://bugs.eclipse.org/367505" target="_blank">Bug 367505</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dba823b0d24f9cff97acfd67bc2439821a73d829" target="_blank">dba823</a></td>
		<td>84 lines</td>
		<td>Fixing Helgrind tests plugin issue with Tycho.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/344504" target="_blank">344504</a></td>
		<td>11466 bytes</td>
		<td>Contributing a Helgrind plugin for Linux Tools Project<br>Attachment 194525: Tarball with the source code of Helgrind plugin</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/364198" target="_blank">364198</a></td>
		<td>116076 bytes</td>
		<td>*cachegrind* files in Helgrind test plugin<br>Attachment 207802: Clean-up of the helgrind test plug-in.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/364747" target="_blank">364747</a></td>
		<td>3471 bytes</td>
		<td>[Perf plug-in] Fixing behavior when no events occurred<br>Attachment 208019: Patch implementing the proposed change - updated</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/365303" target="_blank">365303</a></td>
		<td>11540 bytes</td>
		<td>Enabling perf build into linuxtools<br>Attachment 207785: Patch that sets up pom files for Perf build</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/366734" target="_blank">366734</a></td>
		<td>1715 bytes</td>
		<td>Removing the -U flag from the plug-in<br>Attachment 208394: Patch that removes the -U flag from execution.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/367505" target="_blank">367505</a></td>
		<td>1978 bytes</td>
		<td>Perf hangs when clicking on or creating a configuration<br>Attachment 208806: Patch to fix the p.waitFor() problem found</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;Henrique&nbsp;Debonzi (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=61eb4c0d54fa650b825debf07f75429637782827" target="_blank">61eb4c</a></td>
		<td>104 lines</td>
		<td>Valgrind 3.6 massif new options included.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba34c1cbd8fb91f59dd1e45928043bfa4138132c" target="_blank">ba34c1</a></td>
		<td>219 lines</td>
		<td>Valgrind 3.6 memcheck new options included.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/345482" target="_blank">345482</a></td>
		<td>18201 bytes</td>
		<td>Valgrind tools options (massif, cachegrind, memcheck) does not reflect some options available on latest valgrind.<br>Attachment 196029: Valgrind plugin patch for massif tool.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/345482" target="_blank">345482</a></td>
		<td>21561 bytes</td>
		<td>Valgrind tools options (massif, cachegrind, memcheck) does not reflect some options available on latest valgrind.<br>Attachment 196030: Valgrind plugin patch for memcheck tool.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;U.&nbsp;Thibault (bigfoot.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/349987" target="_blank">349987</a></td>
		<td>22042 bytes</td>
		<td>[LTTng] org.eclipse.linuxtools.lttng StateStrings.java missing some code, other duplicated<br>Attachment 203268: Various fixes and improvements to StateStrings.java</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Dmitry&nbsp;Kozlov (codesourcery.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=02dd417a7c62de33e6ae01b751ee8f909647d0c5" target="_blank">02dd41</a></td>
		<td>98 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelDependent,</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0960bd3597eff9268912bfef380a9c4bc3fe88cb" target="_blank">0960bd</a></td>
		<td>14 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.linux.LinuxOpxmlProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0bcaaade2be4280881ad8a92834d13ee25f9dde5" target="_blank">0bcaaa</a></td>
		<td>134 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileEventConfigTab.
 Part 2.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0ed4fb81ce2b4a3101c33f5c6f779ecd377cec77" target="_blank">0ed4fb</a></td>
		<td>88 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OpUnitMask.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1ca4d3772db61bc0cf67eddafd30b2fbcf4981f1" target="_blank">1ca4d3</a></td>
		<td>18 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.OprofileLaunchPlugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=21a3c1e7bec752b9daa409c4f6a817aa4d44a24d" target="_blank">21a3c1</a></td>
		<td>42 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.opxml.info.EventListProcessor.
 Part 2.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c2121bed265dfb0932d560d375ba64c989423f9" target="_blank">2c2121</a></td>
		<td>102 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.opxml.info.EventListProcessor.
 Part 1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e96cdadde293d596d1370d74043c934caedeca6" target="_blank">2e96cd</a></td>
		<td>78 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileEventConfigTab.
 Part 1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3736ce1cd62615e20a3373f1089b8abc75fb8254" target="_blank">3736ce</a></td>
		<td>14 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.OprofileUiPlugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4868144836a0c08b363cee677e5ba998d834b652" target="_blank">486814</a></td>
		<td>80 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileSetupTab.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4b18be09cc3b90a39cbd41c28b94a6113c59405e" target="_blank">4b18be</a></td>
		<td>109 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelRoot,</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a6bb329157312727be86080cd73f8cb2a75a3ac" target="_blank">5a6bb3</a></td>
		<td>34 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.launch.comfiguration.LaunchOptions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c5907b7a73ca6664e6eaae85c706649b25ab8a7" target="_blank">5c5907</a></td>
		<td>112 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelImage.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6eaf0377fe4eeaf3f7dc1f2361fb6c01a6031247" target="_blank">6eaf03</a></td>
		<td>42 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.checkevent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8172b6d233470881554eb313d3b37a8d07a80983" target="_blank">8172b6</a></td>
		<td>66 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileEventConfigTab.
 Part 3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8ad7ad7b06fb13fd35f6d7dc4fa31d8ac884711a" target="_blank">8ad7ad</a></td>
		<td>72 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelSymbol.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c2d46f096d598e22e05dc1f76b945883fd3ff3e" target="_blank">8c2d46</a></td>
		<td>41 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8dc931f45728d605c41eeb624e1cfed42311f0e0" target="_blank">8dc931</a></td>
		<td>40 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OpEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8dcd0d54caca79e859971e8b6aa06760c7e2e657" target="_blank">8dcd0d</a></td>
		<td>38 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OprofileDaemonEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=96cd7881e165726f5b094a6ecff9cafb690dd842" target="_blank">96cd78</a></td>
		<td>57 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.launch.launching.OprofileManualLaunchConfigurationDelegate.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=97e3ce592bb38bb81c1c0f6475ef1344080de887" target="_blank">97e3ce</a></td>
		<td>54 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4b943458b64b4bb253b23dc7620b840edfce7b8" target="_blank">a4b943</a></td>
		<td>82 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.opxml.modeldata.DependentProcessor,</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a64e05b3fce807cab1455134125cace25a1f9bf6" target="_blank">a64e05</a></td>
		<td>45 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.daemon.OprofileDaemonOptions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a6807430939f44e60d57b225cbf6d4cee223af7d" target="_blank">a68074</a></td>
		<td>78 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileCounter.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bd2a0ff4b5d22467f4c55287570791e07570f0a8" target="_blank">bd2a0f</a></td>
		<td>40 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.opxml.sessions.SessionsProcessor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0d2108f6b149bae950cd808363706e2a609902b" target="_blank">c0d210</a></td>
		<td>56 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.OprofileSAXHandler.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3066b2fe503b27cbf99e82d2b8268d3a35fdad2" target="_blank">c3066b</a></td>
		<td>66 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.linux.LinuxOpcontrolProvider.
 Part 2.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3771121f7899e2f845616935baf8efef3207d2a" target="_blank">c37711</a></td>
		<td>43 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelSymbol.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c50e342232ec1e5dff1cb5ac0ae35600b9d0d97b" target="_blank">c50e34</a></td>
		<td>40 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.XMLProcessor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c5a85154518193ac9ddd75603ea7ef19cafecedf" target="_blank">c5a851</a></td>
		<td>104 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.linux.LinuxOpcontrolProvider.
 Part 1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ccc42ee3d16f262e2c5c68761dd684012d989612" target="_blank">ccc42e</a></td>
		<td>60 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OpInfo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e48143db62e97afcf46c9ad1f559b2646af33af1" target="_blank">e48143</a></td>
		<td>32 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.opxml.model.SymbolsProcessor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef8bab8a736647e75bbf1520bacd7c01e087cd37" target="_blank">ef8bab</a></td>
		<td>42 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f63dd019121d73cd3cfc08ed53157a205e7c680e" target="_blank">f63dd0</a></td>
		<td>92 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelRoot,</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd6f2240f82cf50784730cee75a54faaf050d940" target="_blank">fd6f22</a></td>
		<td>24 lines</td>
		<td>Cleanup leading underscores from identifiers' names in 
org.eclipse.linuxtools.internal.oprofile.core.opxml.info.DefaultsProcessor,</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Etienne&nbsp;Bergeron (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00c62c3308c96ec2ae0d1480b86ef3890aebb861" target="_blank">00c62c</a></td>
		<td>53 lines</td>
		<td>Fix coding style in TmfVirtualTable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d8f198e17b2d5daf9396f99d34d7fe6b37d7a1c" target="_blank">1d8f19</a></td>
		<td>3 lines</td>
		<td>ctf: Remove unused alignment comparison</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=238709ed18cc62bde4c01aa308e56968a1a4f9bc" target="_blank">238709</a></td>
		<td>68 lines</td>
		<td>[ctf] Simplify the logic of the unsigned long comparator.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2eec15fa8df4ba05728158097274ccbff7d731fd" target="_blank">2eec15</a></td>
		<td>4 lines</td>
		<td>Avoid calling reverse on a list.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2f047bfcbc8d2233f610bd0bef67d739dd809619" target="_blank">2f047b</a></td>
		<td>45 lines</td>
		<td>tmf: Remove unused TmfSortedArray.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=577699814c215e6e51a80884f310909a6a5019eb" target="_blank">577699</a></td>
		<td>50 lines</td>
		<td>[ctf] Fix binary search for a long sequence of same timestamps.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=584f23a6868aae533a726052ec71b1377a973370" target="_blank">584f23</a></td>
		<td>151 lines</td>
		<td>tmf: Cleanup TmfStateValue to remove 1-level of indirection.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=594993668f350a335dfbd24cd33e89b46d0862de" target="_blank">594993</a></td>
		<td>4 lines</td>
		<td>Avoid flickering redraw of TmfEventsTable on open.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=75e41738707e0e8cd4334a634280fc39e88bb9c1" target="_blank">75e417</a></td>
		<td>31 lines</td>
		<td>ctf: Plug the unsigned utils comparator into Stream comparator.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7b9585cd9b362ac22bb20b0f31d939e7529ac1e6" target="_blank">7b9585</a></td>
		<td>5 lines</td>
		<td>Avoid multiple seek to the same location.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=83ff34deba3f46dd10651fd89ec401e2dade48a9" target="_blank">83ff34</a></td>
		<td>11 lines</td>
		<td>tmf: Fix NPE in the TimeGraphControl.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=89808b7d2d7c7f27975eb1165c4b1c612b9954f8" target="_blank">89808b</a></td>
		<td>16 lines</td>
		<td>tmf: Fix a method name typo in CtfTmfTrace.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=baefea225705e7ea34fe63d2b1cddb9a5870bf99" target="_blank">baefea</a></td>
		<td>4 lines</td>
		<td>ctf: Fix decoding of an invalid packet id type.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bd8571ca871dec4a7f48e0ad14adabab974b95cc" target="_blank">bd8571</a></td>
		<td>55 lines</td>
		<td>[ctf] Fix coding style issues in BitBuffer.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d7543438d14047efbd421a4d88c0f6707ca2ba1a" target="_blank">d75434</a></td>
		<td>37 lines</td>
		<td>Shortcut string creation in tracing functions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e2daaafd9ae8fb4334cb3b88a1a6ac2d153f0c09" target="_blank">e2daaa</a></td>
		<td>2 lines</td>
		<td>Fix invalid cast which break trace files bigger than 2 gig.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e8d13b2ef23e50ac8686549d3ba44abc4e163c04" target="_blank">e8d13b</a></td>
		<td>88 lines</td>
		<td>ctf: Fix multiple coding style and typo issues while reading code.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f4e31267a25f506a08e3faa34a908f52f29f350a" target="_blank">f4e312</a></td>
		<td>101 lines</td>
		<td>ctf: Remove unused StreamInputReaderComparator.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fe87ef519aad9b85b58fffd6d8e32bb2f08ae9f8" target="_blank">fe87ef</a></td>
		<td>61 lines</td>
		<td>[ctf] Fixes multiple coding style issues while reading ctf Types.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Florian&nbsp;Wininger (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=263252753f3e1f8e8fb00293e4874b5c637ec14a" target="_blank">263252</a></td>
		<td>146 lines</td>
		<td>tmf: Add filtering and highlighting to the State System Explorer</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Francis&nbsp;Giraldeau (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=52b5093ba7363a9392992729985cfa100cbcbecb" target="_blank">52b509</a></td>
		<td>3 lines</td>
		<td>Register the control flow as selection provider</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Francois&nbsp;Chouinard (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/277520" target="_blank">277520</a></td>
		<td>4328 bytes</td>
		<td>Add an entry for LTTng on the project page<br>Attachment 136836: LTTng project info</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">François&nbsp;Rajotte (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b0a612647624d20685be6def20a72eba6576086" target="_blank">0b0a61</a></td>
		<td>14 lines</td>
		<td>Modify LTTng state provider to ignore scheduler wakeups on already-running processes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=15edf0d41e8fd713633bc3c347be3d6b3f35e6d8" target="_blank">15edf0</a></td>
		<td>2 lines</td>
		<td>Add newline awareness to filter and search function of the event view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2734ce3ae4afab5a5ae841ec76e1c379d28a5640" target="_blank">2734ce</a></td>
		<td>204 lines</td>
		<td>[TMF] Add support for 64-bit integers in the history tree</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=401669a5168ecbf49932b15629103b349c880de9" target="_blank">401669</a></td>
		<td>38 lines</td>
		<td>lttng: Add CPU field in control flow view tooltip</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7f08fa6ac161f95fe1d9f2564476e3ec2f168a4d" target="_blank">7f08fa</a></td>
		<td>35 lines</td>
		<td>Change the TimeGraphCombo's filter to a blacklist rather than a whitelist</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Fran�ois&nbsp;Godin (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/323611" target="_blank">323611</a></td>
		<td>1862 bytes</td>
		<td>[TMF] TmfVirtualTable scrolling and slider bugs<br>Attachment 177543: Patch v2</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Geneviève&nbsp;Bastien (versatic.net)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0cbb3a9c2591d7916ab4272bffa3c25daf68adbf" target="_blank">0cbb3a</a></td>
		<td>440 lines</td>
		<td>TMF: Add supplementary folder to experiments</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c5f9387eaed40f7a1989045ff58043c2a1eea19" target="_blank">2c5f93</a></td>
		<td>147 lines</td>
		<td>tmf: Add Variant field handling in CtfTmfEventField</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=431a96d21178f8d2dc31dacfb11d19f59dfcf6f6" target="_blank">431a96</a></td>
		<td>287 lines</td>
		<td>tmf: Move some code to copy/add/remove traces in UI</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5d2b64c8a3de3ee58f363cd51db26c739b8f455a" target="_blank">5d2b64</a></td>
		<td>76 lines</td>
		<td>TMF: Add functions to verify if events are present in a CTF Trace</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e74bb077af3e656e020ba5cb165cec8b372b955" target="_blank">7e74bb</a></td>
		<td>4 lines</td>
		<td>tmf: Call parent before CtfTmfTrace specific initialization</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae07876ea98922d0b04ecaf480aae1cd9f58ad8e" target="_blank">ae0787</a></td>
		<td>60 lines</td>
		<td>TMF: Add Variant field class to CtfTmfEventField</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b93c562a4f7e3080159cafa81fa8f552a4ade4bd" target="_blank">b93c56</a></td>
		<td>41 lines</td>
		<td>tmf: Use same field format in properties and events views</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca5d1f526e5ead481e88d3e1ac76c4bf433daacc" target="_blank">ca5d1f</a></td>
		<td>77 lines</td>
		<td>TMF: Add support for StructDefinition fields to ctfadaptor</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d01ca0ae8db629dd970a8c416a9c51a83f285509" target="_blank">d01ca0</a></td>
		<td>124 lines</td>
		<td>Ctf: Correct endianness when reading ctf integers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef03ffda4cfca9a3d9eeea1a990c32ae6bd7e109" target="_blank">ef03ff</a></td>
		<td>24 lines</td>
		<td>tmf: keep event fields ordering as per ctf metadata</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ff8ef26eafd43296fc268693c3c187c1306571f3" target="_blank">ff8ef2</a></td>
		<td>3769 lines</td>
		<td>TMF: Consolidate some view code into the AbstractTimeGraphView</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Igor&nbsp;Foox (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181102" target="_blank">181102</a></td>
		<td>1682 bytes</td>
		<td>Test failures due to change in SpecfileParser#parseSection<br>Attachment 63056: Patch to fix the tests</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181238" target="_blank">181238</a></td>
		<td>480 bytes</td>
		<td>Superfluous junit entry in .classpath<br>Attachment 63061: Remove junit from classpath</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Jean-Christian&nbsp;Kouamé (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24117eb00b0515afeeeac94317699347db59eaae" target="_blank">24117e</a></td>
		<td>12 lines</td>
		<td>tmf : show environment variables of traces under Experiments</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3ee7910ce0a701fac4a98e486eedf2528f80c1ee" target="_blank">3ee791</a></td>
		<td>58 lines</td>
		<td>CTF : Handle traces with events without eventID</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=46201da19d01a67e96e2f235816bf02aa9d381bb" target="_blank">46201d</a></td>
		<td>210 lines</td>
		<td>ctf: Move integer pretty-printing to IntegerDefinition</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=78789c96d2c5a246073a487363413afa6bdbf08b" target="_blank">78789c</a></td>
		<td>119 lines</td>
		<td>TMF : <a href="https://bugs.eclipse.org/385217" target="_blank">Bug 385217</a> - Display 64 unsigned integers correctly</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=913358994b012e181abc70b7f4649e69e15404b4" target="_blank">913358</a></td>
		<td>91 lines</td>
		<td>tmf : add a mipmap section in the developer guide</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=97f68687f96297de896a5008f7e01ae17d8dc28e" target="_blank">97f686</a></td>
		<td>1011 lines</td>
		<td>tmf : Update the histogram to handle lost events correctly</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9898079defaa94bc3f0cf60dc89b1e863ac304da" target="_blank">989807</a></td>
		<td>2 lines</td>
		<td>tmf : Fix binary search end time in InMemoryBackend</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5664697b061e740e894de908a8cdedf7e247b03" target="_blank">b56646</a></td>
		<td>24 lines</td>
		<td>TMF: change callsite action text</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb1d705816de4ac3111789cac05189b8b81311ca" target="_blank">eb1d70</a></td>
		<td>146 lines</td>
		<td>tmf: Show trace environment variables in the Properties view</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Jeff&nbsp;Johnston (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/210144" target="_blank">210144</a></td>
		<td>49183 bytes</td>
		<td>Changelog plugin should not depend on CVS<br>Attachment 83114: Changelog plugin patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Jeremy&nbsp;Handcock (aperte.org)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82195" target="_blank">82195</a></td>
		<td>1733 bytes</td>
		<td>[RPM] Refactor org.eclipse.cdt.rpm.core<br>Attachment 21390: Patch for org.eclipse.cdt.rpm-feature</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82195" target="_blank">82195</a></td>
		<td>308001 bytes</td>
		<td>[RPM] Refactor org.eclipse.cdt.rpm.core<br>Attachment 21391: Patch for org.eclipse.cdt.rpm.core</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82195" target="_blank">82195</a></td>
		<td>50508 bytes</td>
		<td>[RPM] Refactor org.eclipse.cdt.rpm.core<br>Attachment 21392: Patch for org.eclipse.cdt.rpm.core.tests</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82195" target="_blank">82195</a></td>
		<td>110055 bytes</td>
		<td>[RPM] Refactor org.eclipse.cdt.rpm.core<br>Attachment 21393: Patch for org.eclipse.cdt.rpm.ui</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82196" target="_blank">82196</a></td>
		<td>6233 bytes</td>
		<td>[RPM] Move propertypage plug-in to org.eclipse.cdt.rpm.ui<br>Attachment 21453: Patch for org.eclipse.cdt.rpm.core</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82196" target="_blank">82196</a></td>
		<td>36567 bytes</td>
		<td>[RPM] Move propertypage plug-in to org.eclipse.cdt.rpm.ui<br>Attachment 21454: Patch for org.eclipse.cdt.rpm.propertypage</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/82196" target="_blank">82196</a></td>
		<td>26856 bytes</td>
		<td>[RPM] Move propertypage plug-in to org.eclipse.cdt.rpm.ui<br>Attachment 21455: Patch for org.eclipse.cdt.rpm.ui</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/96849" target="_blank">96849</a></td>
		<td>1694 bytes</td>
		<td>[OProfile] Build doesn't fail when opxml build fails<br>Attachment 21850: Patch for org.eclipse.cdt.oprofile.core.linux</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">John&nbsp;Dallaway (dallaway.org.uk)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/329710" target="_blank">329710</a></td>
		<td>950 bytes</td>
		<td>getGCDALocations() implementation is not robust<br>Attachment 182816: CovManager.java.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/330810" target="_blank">330810</a></td>
		<td>680 bytes</td>
		<td>Chart View viewer should be borderless<br>Attachment 183571: ChartView.java.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/340638" target="_blank">340638</a></td>
		<td>1608 bytes</td>
		<td>GProf view presents border around table<br>Attachment 191664: GmonView.java.patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Jérémie&nbsp;Galarneau (efficios.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1e34d3c84d499dad12ee6ade80eda7514142b5c9" target="_blank">1e34d3</a></td>
		<td>3 lines</td>
		<td>Fix Float reading in CTF traces</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Ken&nbsp;Mising&nbsp;name (msn.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/350593" target="_blank">350593</a></td>
		<td>5161 bytes</td>
		<td>ChangeLog does not consider a dirty ChangeLog editor as a change 
to the ChangeLog file and adds new ChangeLog entries to the editor<br>Attachment 198744: Adds dirty detection detection and pass it to GNUFormat</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/350593" target="_blank">350593</a></td>
		<td>1476 bytes</td>
		<td>ChangeLog does not consider a dirty ChangeLog editor as a change 
to the ChangeLog file and adds new ChangeLog entries to the editor<br>Attachment
 198745: Added a field, getter and setter so the boolean flag can be 
passed to GNUFormat to force it to merge a ChangeLog instead of creating
 new entries.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/350593" target="_blank">350593</a></td>
		<td>1900 bytes</td>
		<td>ChangeLog does not consider a dirty ChangeLog editor as a change 
to the ChangeLog file and adds new ChangeLog entries to the editor<br>Attachment 198746: Added dirty editor detection support by checking the boolean flag included by ChangeLogEditor.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Krzysztof&nbsp;Daniel (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7d303e15c0fed77e309a813dfcf882bb8bcd78a6" target="_blank">7d303e</a></td>
		<td>50 lines</td>
		<td><a href="https://bugs.eclipse.org/366698" target="_blank">Bug 366698</a> - Kill old install and provision targets</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=aec369f605a83aec45135f739659c25b9fa3be39" target="_blank">aec369</a></td>
		<td>2 lines</td>
		<td><a href="https://bugs.eclipse.org/367942" target="_blank">Bug 367942</a> - setPDEBuildPath does nothing currently</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d101b3290df308930f6e0f69336289a0e18dd8dd" target="_blank">d101b3</a></td>
		<td>12 lines</td>
		<td><a href="https://bugs.eclipse.org/367940" target="_blank">Bug 367940</a> - ant buildTests should fail if underlying equinox returns 13</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/350304" target="_blank">350304</a></td>
		<td>2051 bytes</td>
		<td>[pdebuild] Clean up unnecessary logging<br>Attachment 203120: Patch proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/366698" target="_blank">366698</a></td>
		<td>4588 bytes</td>
		<td>Kill old install and provision targets<br>Attachment 209009: Second proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/366701" target="_blank">366701</a></td>
		<td>4764 bytes</td>
		<td>Is org.eclipse.update.core needed in the bootstrap step?<br>Attachment 209062: Work to be retested after PDE Build dependency on update.core is resolved.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/367727" target="_blank">367727</a></td>
		<td>3442 bytes</td>
		<td>Incorrect error message when eclipse-build version does not match the source tarbals<br>Attachment 208994: Fix proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/367744" target="_blank">367744</a></td>
		<td>1294 bytes</td>
		<td>Verify if the JAVA_HOME is set before build starts<br>Attachment 208945: Patch v4 in git format</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/367940" target="_blank">367940</a></td>
		<td>2737 bytes</td>
		<td>ant buildTests should fail if underlying equinox returns 13<br>Attachment 209077: Fix proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/367942" target="_blank">367942</a></td>
		<td>894 bytes</td>
		<td>setPDEBuildPath does nothing currently<br>Attachment 209074: Fix in line with Alex suggestions</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Krzysztof&nbsp;Daniel (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0c3a5d17d9aeeadf57141aeaba3b65d1ff533584" target="_blank">0c3a5d</a></td>
		<td>10 lines</td>
		<td>Verify if the JAVA_HOME is set before build starts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=90afd93ab5f0d085229b81971e5391107df0ef42" target="_blank">90afd9</a></td>
		<td>8 lines</td>
		<td><a href="https://bugs.eclipse.org/367727" target="_blank">Bug 367727</a> - Incorrect error message when eclipse-build version does not match the source tarbals</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Kyu&nbsp;Lee (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/179327" target="_blank">179327</a></td>
		<td>18470 bytes</td>
		<td>Separate *Parser classes into plug-ins<br>Attachment 66527: removing dependencies for JDT, CDT and parsers</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Lawrie&nbsp;Nichols (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/296228" target="_blank">296228</a></td>
		<td>1853 bytes</td>
		<td>No profiling data generated - wrong image filter?<br>Attachment 167174: Patch for oprofile abstract launcher</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">lmcpata (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=17429dca4b2a18c5691642864f7daf757588f394" target="_blank">17429d</a></td>
		<td>3671 lines</td>
		<td>Fix for custom parsers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cc215be76b9c25a1ee7640a3e8df1f92bb56fe4d" target="_blank">cc215b</a></td>
		<td>15 lines</td>
		<td>Fix for state experiment manager coalescing.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Lukas&nbsp;Berk (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a3006a0d84a904a4bb6e37a2b0104d6e06aec1c" target="_blank">0a3006</a></td>
		<td>51 lines</td>
		<td>Add functionality and API to run script locally</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0cd2c8f4a2cbe2f9459daeb780d6a966e457afdc" target="_blank">0cd2c8</a></td>
		<td>388 lines</td>
		<td>Add new Systemtap Wizard for new scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=21f3355c4cdcd607146d5e5451add1ba21201064" target="_blank">21f335</a></td>
		<td>456 lines</td>
		<td>Re-write of systemtap probe and function parsers.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3305e4f915ecba324dc901a24eca20a59d4b9c67" target="_blank">3305e4</a></td>
		<td>8 lines</td>
		<td>Remove -v and -p1 parameters from stap '' -v -p1 -L ** command</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43a682f1eeb64214fcd785b71493bb0367ccad44" target="_blank">43a682</a></td>
		<td>193 lines</td>
		<td>Check that user belongs to stapdev for callgraph views</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44655e3d06bd60b9cf4733dbf0f5d404b8251d8e" target="_blank">44655e</a></td>
		<td>2 lines</td>
		<td>Remove the unused imports</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9afba9f873e1df63b5a3cc1f1bb67497c6914d92" target="_blank">9afba9</a></td>
		<td>8 lines</td>
		<td>Correct the location and spacing of externalized strings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a224b5c3af71874f4c93f3f202377b2cfd966e66" target="_blank">a224b5</a></td>
		<td>36 lines</td>
		<td>Change how runStap is passed the stap arguments</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Marc&nbsp;Dumais (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/316455" target="_blank">316455</a></td>
		<td>39515 bytes</td>
		<td>[LTTng] State system minor improvements<br>Attachment 180879: Updated patch, following rebase to latest of TRUNK as of 2010-10-14</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Marc&nbsp;Khouzam (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292172" target="_blank">292172</a></td>
		<td>390 bytes</td>
		<td>Wrong release version on oprofile move_opxml script<br>Attachment 149456: Fix</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Marc-Andre&nbsp;Laperle (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1b3bb112d28d65289cc7ae527a4774e5c328bb37" target="_blank">1b3bb1</a></td>
		<td>345 lines</td>
		<td>Add a View guide to the TMF documentation</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=55e24ad1e21fedff03af0681ff586b6d79cf0c0f" target="_blank">55e24a</a></td>
		<td>1 lines</td>
		<td>Add .DS_Store to gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e7a874a03bb6919bb336fb13277596e0f81569b" target="_blank">5e7a87</a></td>
		<td>938 lines</td>
		<td>Remove UI dependencies in tmf.core.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=65482f2b5046748acce364ecb16697aad06cbef1" target="_blank">65482f</a></td>
		<td>30 lines</td>
		<td>Fix IllegalArgumentException in Colors view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=787c5870db04b76ec2c076a6357d7a27f5a3a28e" target="_blank">787c58</a></td>
		<td>122 lines</td>
		<td>Add target platforms for Eclipse 3.8, 4.2, 4.3 and staging (4.4)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=790a1eaf66d546f89e4ae855e73e9ba641d43f1b" target="_blank">790a1e</a></td>
		<td>175 lines</td>
		<td>[TMF] Remove TmfStringLocation</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d3785fbefb627b37165fcaace386f3e51008791" target="_blank">7d3785</a></td>
		<td>6 lines</td>
		<td>Fix some warnings when compiling with 4.4 targetting 4.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8537d1ebd1d1b85213c91474cc94efbfcf88bed8" target="_blank">8537d1</a></td>
		<td>181 lines</td>
		<td>[TMF] Handle custom traces in TmfTraceType in a more consistent way</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8714534cd3caedc8641fa5976b53a61b66f8d90b" target="_blank">871453</a></td>
		<td>1135 lines</td>
		<td>Add timezones to preference page</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=92b86f37d6917a776a833ccdceef219bfaa1653f" target="_blank">92b86f</a></td>
		<td>23 lines</td>
		<td><a href="https://bugs.eclipse.org/407474" target="_blank">Bug 407474</a> - Exceptions thrown when opening/closing trace with no event</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=944172362d018ab163480725ba56bef5d716e12a" target="_blank">944172</a></td>
		<td>118 lines</td>
		<td>[TMF] Remove TmfTrace.setIndexer and indexer param in ctor</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac59e204ec1e8cad623db3f1266b42490417442e" target="_blank">ac59e2</a></td>
		<td>12 lines</td>
		<td>Specify target runtime environments in build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aca0ca5483f296545dbcf267d50da41b4eee440b" target="_blank">aca0ca</a></td>
		<td>4779 lines</td>
		<td>BTree index on disk</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aea9bfe1fffe8f6a4efeae3427f0078f12e69a69" target="_blank">aea9bf</a></td>
		<td>345 lines</td>
		<td>Add a View guide to the TMF documentation</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b129bb7105a71dbbae4d4eb7f62b4ba5e2ea1993" target="_blank">b129bb</a></td>
		<td>17 lines</td>
		<td><a href="https://bugs.eclipse.org/416574" target="_blank">Bug 416574</a> - Fix NPE when deleting supplementary files in experiment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b6ef66ba8bb407f71ecf8f3a8fda73f914b605fa" target="_blank">b6ef66</a></td>
		<td>58 lines</td>
		<td><a href="https://bugs.eclipse.org/416578" target="_blank">Bug 416578</a> - [TMF] Select/Deselect All buttons in delete supplementary files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4fac03a09bbe57fb2c3e12f69833f58fbb3cd0e" target="_blank">c4fac0</a></td>
		<td>46 lines</td>
		<td><a href="https://bugs.eclipse.org/416316" target="_blank">Bug 416316</a> - New &gt; Tracing Project appears in unrelated perspectives</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c81826411043e43a0c7a4c74466d10d89879b167" target="_blank">c81826</a></td>
		<td>13 lines</td>
		<td><a href="https://bugs.eclipse.org/417036" target="_blank">Bug 417036</a> - [TMF] Legacy import: Trace type is not set after importing custom trace</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e94a7679dd349254b7f78aaaffe7fd08528a6f8d" target="_blank">e94a76</a></td>
		<td>446 lines</td>
		<td>Integrate Babeltrace CTF tests and fix parsing problems</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f07537acb492eb675fe653526c0a3968ad14b07c" target="_blank">f07537</a></td>
		<td>36 lines</td>
		<td>[TMF] Fix current API errors for version 2.2</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Martin&nbsp;Oberhuber (windriver.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/354342" target="_blank">354342</a></td>
		<td>1955 bytes</td>
		<td>The version number can not be changed after the ValgrindOptionTab has been initialized<br>Attachment 201221: patch v1</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/360085" target="_blank">360085</a></td>
		<td>2619 bytes</td>
		<td>Valgrind doesn't always clear its error markers when it should<br>Attachment 204715: patch v1</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Marvin&nbsp;Schmidt (gmx.net)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/271657" target="_blank">271657</a></td>
		<td>3445 bytes</td>
		<td>Make location of SDK sources easily changable<br>Attachment 131305: Use fileName property instead of hardcoded path</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/272820" target="_blank">272820</a></td>
		<td>11941 bytes</td>
		<td>Tweak build scripts, clarify separation of distribution and build<br>Attachment 132609: Updated patch, added devBuild target</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/274357" target="_blank">274357</a></td>
		<td>1030 bytes</td>
		<td>Executing simply `ant ` in clean checkout fails<br>Attachment 135132: remove devBuild target, depend on conditional fetch target</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Mathieu&nbsp;Denis (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/382438" target="_blank">382438</a></td>
		<td>2484 bytes</td>
		<td>[TMF] NullPointerException when closing statistics view<br>Attachment 217898: Fix for <a href="https://bugs.eclipse.org/382438" target="_blank">Bug 382438</a>: null pointer exception when closing statistics view</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Mathieu&nbsp;Denis (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1cc34943150b79e8f17bdee74a61ee2f7cd9ceca" target="_blank">1cc349</a></td>
		<td>285 lines</td>
		<td>tmf: Updates statistics test cases</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1f0bb2ddf8727c4631810c7b835db28f835ff4a7" target="_blank">1f0bb2</a></td>
		<td>4296 lines</td>
		<td>tmf: Generalization of the statistics view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2de8425ebdc38d6d268b6b84ad44a272e7e1f490" target="_blank">2de842</a></td>
		<td>149 lines</td>
		<td>tmf: Refactor the statistics</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5f90ea16ce2a6706bf17ce3a47869595666c7fa4" target="_blank">5f90ea</a></td>
		<td>8 lines</td>
		<td>tmf: Fix reload of the same trace for statistics</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5fca88a64e6717627424e8882e2228c28a32a48d" target="_blank">5fca88</a></td>
		<td>112 lines</td>
		<td>tmf: Complete the statistics API</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=670aa6a8f01b0693cacd6b375dcde6ec0de663db" target="_blank">670aa6</a></td>
		<td>23 lines</td>
		<td>tmf: some updates to the statistics</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72c1dc07536399270f28f69e3fccc07b869caa9a" target="_blank">72c1dc</a></td>
		<td>3 lines</td>
		<td>tmf: Correct event type in statistics</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=803c5f2dee202cb2a726fc642b30b0ca257c8d95" target="_blank">803c5f</a></td>
		<td>6 lines</td>
		<td>Fix for <a href="https://bugs.eclipse.org/382438" target="_blank">Bug 382438</a>: null pointer exception when closing statistics view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81418ec1224239952a7980635700795986311749" target="_blank">81418e</a></td>
		<td>937 lines</td>
		<td>tmf: formatting of tmf.ui.statistics</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81bd680a9b4d080f11b46385e5166ca5a9717103" target="_blank">81bd68</a></td>
		<td>52 lines</td>
		<td>tmf: Correct the statistics partial event count</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8b4fadfdd27f749aaec6072ff6e1c1044b33118d" target="_blank">8b4fad</a></td>
		<td>97 lines</td>
		<td>Add a simple example of how to use the state system with a CTF kernel trace</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5d37722eaad66a3d8289e683e553fabd68ba470" target="_blank">b5d377</a></td>
		<td>5 lines</td>
		<td>tmf: Dispose of the model in the statistics viewer</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cbc6aff52149ae67d65957220ba99513f5640da4" target="_blank">cbc6af</a></td>
		<td>640 lines</td>
		<td>tmf: Add a column in the statistics view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e68ddcbc7dc45cd49dc1e6d45b70dcd2f4c22014" target="_blank">e68ddc</a></td>
		<td>1934 lines</td>
		<td>tmf: Use tabs in statistics view for each traces</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e7370dba3de59766eb562112edfdc1d353d07d3a" target="_blank">e7370d</a></td>
		<td>144 lines</td>
		<td>tmf: Update test cases of the statistics</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/355551" target="_blank">355551</a></td>
		<td>7469 bytes</td>
		<td>[LTTng] Statistics view - Correct calculation of cumulative CPU time<br>Attachment 202110: Fix how the cumulative CPU time is updated</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Mathieu&nbsp;Denis (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1de21ae88fefb31d1edd81e509ca93222b5259f" target="_blank">d1de21</a></td>
		<td>8 lines</td>
		<td>Fixed lost event bug.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/355084" target="_blank">355084</a></td>
		<td>2067 bytes</td>
		<td>[LTTng] latency analysis - the second trace to be selected sometimes doesn't appear<br>Attachment 201733: Clear the histogram selected timerange for the latency view</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Matt&nbsp;Whitlock (mattwhitlock.name)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/302256" target="_blank">302256</a></td>
		<td>2277 bytes</td>
		<td>build.xml missing -Xmx on forked java executions<br>Attachment 159056: build.xml-r24216.patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Matthew&nbsp;Khouzam (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0733f3b80816cf25a275ed72e54918abbcad570e" target="_blank">0733f3</a></td>
		<td>254 lines</td>
		<td>improve test coverage and fix go to last event bug</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=099df0107b394ad0abd9f40e88919052b6f7766d" target="_blank">099df0</a></td>
		<td>92 lines</td>
		<td>Fix seek bug.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=117c2cdb3591bc8797cdfa73e4d938d90f1bc55b" target="_blank">117c2c</a></td>
		<td>79 lines</td>
		<td>Generalized trace test added. Can be useful for profiling.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=200ad02b0211ee13abbca3a2e28c965233625a17" target="_blank">200ad0</a></td>
		<td>108 lines</td>
		<td>Added a headless test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24107ab70633b4a3229fc57dae2af02d5296ee62" target="_blank">24107a</a></td>
		<td>67 lines</td>
		<td>Added getOffset to a trace and updated benchmark.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=264ffaa8e283fa1668bb5c57d1e230b9dbaee38e" target="_blank">264ffa</a></td>
		<td>228 lines</td>
		<td>Added faster indexed seeks.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2919a69f6f41680224803d99f3acec8590370540" target="_blank">2919a6</a></td>
		<td>343 lines</td>
		<td>Change certain classes to use ITmfEvent instead of TmfEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fd7a9dc550d8df9d9a2cb9be39b4de2ef98880d" target="_blank">2fd7a9</a></td>
		<td>1 lines</td>
		<td>add LTTng icon to LTTng Traces</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3f5276094101a6b3fd7da0fefb83421d2ed92278" target="_blank">3f5276</a></td>
		<td>7 lines</td>
		<td>Add Lttng 2.0 trace to Lttng View</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=408f27d3450e68e9bbc3a543ef925fed170e2bb9" target="_blank">408f27</a></td>
		<td>8 lines</td>
		<td>fix seek with offsetted timestamps.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43ddc7d7856715dab1be8b85eee892ec13733b92" target="_blank">43ddc7</a></td>
		<td>88 lines</td>
		<td>fix post-merge to get it to compile.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=584361456d5e30e042c4d1514229a1188be44587" target="_blank">584361</a></td>
		<td>7 lines</td>
		<td>update events table in lttng.ui to have an ITmfEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5d2c183b768109a95154b4a0f2e8374b6cf9560e" target="_blank">5d2c18</a></td>
		<td>2 lines</td>
		<td>Change Icon from a giant mole to a reasonable penguin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e260bf62b056088f0862337d0ab95c6b0ca3d12" target="_blank">5e260b</a></td>
		<td>18 lines</td>
		<td>Add a headless test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a47bb780be058a2ab9f47b22cd141f808a5580c" target="_blank">7a47bb</a></td>
		<td>89 lines</td>
		<td>Fix warnings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c5b11f630b587e89547a612f62f9effd6d85eb1" target="_blank">8c5b11</a></td>
		<td>21 lines</td>
		<td>add Environment variables to ctf interface</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a3fcc17f5102de27f1d2e4cd71f77952f944c859" target="_blank">a3fcc1</a></td>
		<td>4 lines</td>
		<td>Add support for offsets in event creation</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a97888f084252debbb4543f8d38e424f1fe973df" target="_blank">a97888</a></td>
		<td>6 lines</td>
		<td>Added an interesting headless test. It is more there to show how someone</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aa098c35f8ee377445e288493063a266b81264fc" target="_blank">aa098c</a></td>
		<td>7062 lines</td>
		<td>internalize some CTF API</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d0bf7c0ef35d7f04fd7f07848d8a8a90d78ff515" target="_blank">d0bf7c</a></td>
		<td>149 lines</td>
		<td>Improved test coverage.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d2ada18550e299323a68a43746f6b5d23406dcf5" target="_blank">d2ada1</a></td>
		<td>467 lines</td>
		<td>Add support for seeks by index.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d98555f4d955e1838171372f54907c26b4c4033d" target="_blank">d98555</a></td>
		<td>117 lines</td>
		<td>Added clocks to integer definitions and removed warnings from IOStructGen.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dad5bdc62af79bbf033f289556d0d8716e66fe44" target="_blank">dad5bd</a></td>
		<td>74 lines</td>
		<td>add benchmarks</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e01715736570787024910bdb3cf25dfa30ae4469" target="_blank">e01715</a></td>
		<td>137 lines</td>
		<td>Add environment variables view widget</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e82442d1b98114579637f1cd4139a25216ccd833" target="_blank">e82442</a></td>
		<td>8 lines</td>
		<td>Added getOffset to a trace and updated benchmark.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb53d527a2cadcb4f367ecbcc9e0a127c39c2a4d" target="_blank">eb53d5</a></td>
		<td>143 lines</td>
		<td>Add support in the UI for LTTng 2.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef3e3f83bea4e1c1071f1d692096eafb9a444f65" target="_blank">ef3e3f</a></td>
		<td>70 lines</td>
		<td>add fallback for seeking by unindexed traces</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f61e1b03d280a1f7b634db545c315b655d955a12" target="_blank">f61e1b</a></td>
		<td>219 lines</td>
		<td>Change output of ctf toStrings to be more human readable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f83095792d29998aaa60da3fb2a5da7fb247e8ca" target="_blank">f83095</a></td>
		<td>2666 lines</td>
		<td>Define CTF API</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f92741bd358479a51bc4ab56fb10f953a52cb6bd" target="_blank">f92741</a></td>
		<td>123 lines</td>
		<td>changed TmfEvent to ITmfEvent</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292414" target="_blank">292414</a></td>
		<td>16532 bytes</td>
		<td>[LTTng] Include Legend in Control Flow and Resources View<br>Attachment 185668: Includes legends in control flow view and resource view</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/325661" target="_blank">325661</a></td>
		<td>86136 bytes</td>
		<td>[LTTng] Performance improvements<br>Attachment 182076: Backend performance improvements</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/374541" target="_blank">374541</a></td>
		<td>9801 bytes</td>
		<td>Test coverage is not as high as it could be.<br>Attachment 212798: a patch to increase code coverage of ctf components</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Matthias&nbsp;Klose (ubuntu.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/293946" target="_blank">293946</a></td>
		<td>96235 bytes</td>
		<td>regenerated eclipse-build-additionalArchs.tar.bz2 (new platforms and 64bit fixes)<br>Attachment 151086: regenerated tarball</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/293946" target="_blank">293946</a></td>
		<td>936 bytes</td>
		<td>regenerated eclipse-build-additionalArchs.tar.bz2 (new platforms and 64bit fixes)<br>Attachment 151087: example 64bit diff</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/293948" target="_blank">293948</a></td>
		<td>6214 bytes</td>
		<td>updated patches/eclipse-add* patches<br>Attachment 151090: eclipse-add-archs-executable.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/293948" target="_blank">293948</a></td>
		<td>3228 bytes</td>
		<td>updated patches/eclipse-add* patches<br>Attachment 151091: eclipse-add-archs-filesystem.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/293948" target="_blank">293948</a></td>
		<td>5507 bytes</td>
		<td>updated patches/eclipse-add* patches<br>Attachment 151093: eclipse-add-archs-swt.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/293948" target="_blank">293948</a></td>
		<td>4676 bytes</td>
		<td>updated patches/eclipse-add* patches<br>Attachment 151094: eclipse-add-ppc64-sparc64-s390-s390x.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/293951" target="_blank">293951</a></td>
		<td>4960 bytes</td>
		<td>support additional archs in build scripts<br>Attachment 151095: patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Michel&nbsp;Dagenais (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e4066ac82c2634f4bb027ea51e45e68d38292e0b" target="_blank">e4066a</a></td>
		<td>73 lines</td>
		<td>lttng: State of processes from LTTng kernel traces</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">minoo&nbsp;ziaei (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/353447" target="_blank">353447</a></td>
		<td>2618 bytes</td>
		<td>Missing exported rpmstubby package<br>Attachment 201086: rpmstubby and rpm.ui.editor patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Neil&nbsp;Guzman (unused-10-15-18-106.yyz.redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b062e63d77718b54e6ec960ad99ee3fa7c666abd" target="_blank">b062e6</a></td>
		<td>43 lines</td>
		<td>Latest maven java specfile guideline for rpmstubby</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Neil&nbsp;Guzman (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=062888d198fd24e0075251244a05f4aad11903b2" target="_blank">062888</a></td>
		<td>182 lines</td>
		<td>Fix sonar violations for RPM and lttng</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=10d599fc5181dac1f71550d3993d17dfba1dd68a" target="_blank">10d599</a></td>
		<td>230 lines</td>
		<td>RPM: modify behaviour of hyperlinks B#416446</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=147fe95b9f3f3fd3d813166f804685bec2ad904c" target="_blank">147fe9</a></td>
		<td>14 lines</td>
		<td>rpm: resolve defines will resolve whole word only</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1cfb57451f64d197cc97233bd3f8494b8e078eb6" target="_blank">1cfb57</a></td>
		<td>608 lines</td>
		<td>RPM: Add menu for building RPMs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25b44117fffac7ec121daae6b2c0c438f4f1545e" target="_blank">25b441</a></td>
		<td>207 lines</td>
		<td>RPM: working set option for RPM Project B#413732</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=366b253f036a61092ffe2567b5ea263af1a699a9" target="_blank">366b25</a></td>
		<td>43 lines</td>
		<td>RPM: remove unresolved urls as option B#414882</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b778b100bd3c717aefb5a083a4a73cc318fd9eb" target="_blank">3b778b</a></td>
		<td>8 lines</td>
		<td>RPMStubby: remove most feature project stub option</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=425cbaf44f604482455bb6456a2f2e84f51089d0" target="_blank">425cba</a></td>
		<td>131 lines</td>
		<td>RPM: evaluate %{?...} macros</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50a2ab8f883f23adbb146f23ef1061f61e4adc41" target="_blank">50a2ab</a></td>
		<td>1205 lines</td>
		<td>RPM: download and prepare sources</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=564a439e7697b27f523d0eee480d3ef606818fd1" target="_blank">564a43</a></td>
		<td>157 lines</td>
		<td>RPMStubby: eclipse template uses tycho if possible</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c3a3e3522f647bf2271678950317fba00fbecb9" target="_blank">5c3a3e</a></td>
		<td>1043 lines</td>
		<td>RPMStubby: Perl Makefile template</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=73e5e28fc1f81ee33925f096d512a9da6058c7ab" target="_blank">73e5e2</a></td>
		<td>941 lines</td>
		<td>RPMStubby: Python Egg template B#350065</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81e1945f0719cd2935b41ffb401ab3d60d029853" target="_blank">81e194</a></td>
		<td>12 lines</td>
		<td>RPMStubby: Stub specfile in proper dir B#414589</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9068febd9bfe936b038ab3f0ca76a5d74774b0ea" target="_blank">9068fe</a></td>
		<td>71 lines</td>
		<td>RPM &amp; RPMStubby: fix copyright dates</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a8a65c79bbb74c250b7d4932eed53e456783b6a9" target="_blank">a8a65c</a></td>
		<td>422 lines</td>
		<td>RPM: remove export wizard and properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aaf9a2d7db8b1a0f140de4c4fd649e97c3170368" target="_blank">aaf9a2</a></td>
		<td>259 lines</td>
		<td>RPM: create patches through hyperlink B#413508</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c780ec5ded13b1b078004d4edc576e3c94fe800f" target="_blank">c780ec</a></td>
		<td>91 lines</td>
		<td>RPM: add toolbar menu icons for RPM Build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dc7c6fb9cdfd629467b1fe38e387668fff697cd7" target="_blank">dc7c6f</a></td>
		<td>985 lines</td>
		<td>RPMStubby: Ruby Gem template B#350066</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e3e66bb02987d72feef3f0cf98e3147c7278ac81" target="_blank">e3e66b</a></td>
		<td>14 lines</td>
		<td>RPMStubby: Proper names and define</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f49237262dc7977acd1c7bfb6239881dd3d3563b" target="_blank">f49237</a></td>
		<td>55 lines</td>
		<td>rpm: Autocompletion fix for pkgs with '.' or '+'</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Niels&nbsp;Thykier (thykier.net)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/286571" target="_blank">286571</a></td>
		<td>7052 bytes</td>
		<td>Bashism in the build scripts<br>Attachment 144470: Fixes bashisms in the build files.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/286824" target="_blank">286824</a></td>
		<td>3826 bytes</td>
		<td>Separate applying patches and extracting source<br>Attachment 145729: Same as last time, except this time without conflicts.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/286825" target="_blank">286825</a></td>
		<td>1149 bytes</td>
		<td>[eclipse-build] Default to outputting build logs to stdout and not .txt files<br>Attachment 176057: Disable logs in o.e.swt/tasks/build.xml</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/286826" target="_blank">286826</a></td>
		<td>376 bytes</td>
		<td>Tee to build-&lt;timestamp&gt;.log by default<br>Attachment 145330: Makes build.sh pipe to tee and create a build log with a timestamp.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291531" target="_blank">291531</a></td>
		<td>2710 bytes</td>
		<td>[Patch] Add a target to extract the swt bundle from org.eclipse.osgi/<br>Attachment 148939: The uncolored patch.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292078" target="_blank">292078</a></td>
		<td>3723 bytes</td>
		<td>libgnomeproxy patches.<br>Attachment 149397: Modifications to the build.xml</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292078" target="_blank">292078</a></td>
		<td>843 bytes</td>
		<td>libgnomeproxy patches.<br>Attachment 149400: Patch of libgnomeproxy's makefile</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/294557" target="_blank">294557</a></td>
		<td>422 bytes</td>
		<td>eclipse-pdebuild should fail on error.<br>Attachment 151657: Enabled "Fail on first error" in pdebuild.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/294557" target="_blank">294557</a></td>
		<td>1113 bytes</td>
		<td>eclipse-pdebuild should fail on error.<br>Attachment 159666: Makes pdebuild propagate the exit code from eclipse.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/294559" target="_blank">294559</a></td>
		<td>516 bytes</td>
		<td>build.sh does not fail of ant fails.<br>Attachment 151660: Makes build.sh propagate the error code from ant.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/303170" target="_blank">303170</a></td>
		<td>1396 bytes</td>
		<td>Patch for pdebuild.xml to build ecf.<br>Attachment 159415: The patch to pdebuild.xml</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/303351" target="_blank">303351</a></td>
		<td>3916 bytes</td>
		<td>Patch to remove Build-dependency on jetty5.<br>Attachment 159595: Patcht to remove B-D on jetty5</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/305244" target="_blank">305244</a></td>
		<td>1857 bytes</td>
		<td>Patch to build o.e.osgi.util from source<br>Attachment 162764: Updates o.e.osgi.util build.properties</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/322271" target="_blank">322271</a></td>
		<td>2277 bytes</td>
		<td>[eclipse-build][debian] eclipse-pdebuild.sh does not pass -data and uses -vmargs<br>Attachment 191501: Refreshed the original patch for the git migration</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/340422" target="_blank">340422</a></td>
		<td>923 bytes</td>
		<td>[eclipse-build] Please remove o.e.osgi.util/src.zip after extraction (buildSDKSource.sh)<br>Attachment 191844: Remove src.zip + .class files in o.e.osgi.util</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Otavio&nbsp;Pontes (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f67202d9f6817dc7dd16e46c02d110708167254f" target="_blank">f67202</a></td>
		<td>132 lines</td>
		<td>Fill the default callgraph launch configuration with new attributes</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Otavio&nbsp;Pontes (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=104be8caedb2f54a28a716d86803beb817101ea1" target="_blank">104be8</a></td>
		<td>21 lines</td>
		<td>Fix <a href="https://bugs.eclipse.org/351477" target="_blank">Bug 351477</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=270dbfff315e44cb10bfc3018f894f6671f859f5" target="_blank">270dbf</a></td>
		<td>2 lines</td>
		<td>Documentation, Import Modules task has a broken link  <a href="https://bugs.eclipse.org/353635" target="_blank">Bug 353635</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40a1d6661fadc9b72fcf73bddd0e10b588e9a738" target="_blank">40a1d6</a></td>
		<td>57 lines</td>
		<td>Modify verbosity flag to accept levels of verbosity.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c82d8af7aed5b9536622b9f6cc358ec8827c8c2" target="_blank">5c82d8</a></td>
		<td>57 lines</td>
		<td>Modify verbosity flag to accept levels of verbosity.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5fa024f8085275d28e1d1a2cfd51f796d4341cb3" target="_blank">5fa024</a></td>
		<td>2 lines</td>
		<td>Documentation, Import Modules task has a broken link  <a href="https://bugs.eclipse.org/353635" target="_blank">Bug 353635</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d18c50b53b0741b79b4cb2a38a5a7e2cd345eee3" target="_blank">d18c50</a></td>
		<td>23 lines</td>
		<td>NPE when opening .h/.c file in SystemTap IDE</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/345010" target="_blank">345010</a></td>
		<td>4014 bytes</td>
		<td>Null Pointer Exception is raised when I open a file in Kernel Source view in Systemtap IDE<br>Attachment 203509: Systemtap: Using only stp editors to open files in stap perspective</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/351355" target="_blank">351355</a></td>
		<td>5347 bytes</td>
		<td>gprof: support 64-bit gmon files in ppc64<br>Attachment 205525: Getting Symbol table correctly in ppc64</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/351477" target="_blank">351477</a></td>
		<td>3512 bytes</td>
		<td>When running a systemtap plugin to draw a graph it displays the graph wizard even if the connection fails.<br>Attachment 199275: Improved patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/353635" target="_blank">353635</a></td>
		<td>1396 bytes</td>
		<td>Help: systemtap Dashboard Guide -&gt; Importing Modules has a broken link<br>Attachment 200756: Patch to fix the reported problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/353809" target="_blank">353809</a></td>
		<td>10784 bytes</td>
		<td>Function Callgraph profile configuration does not support -vv and -vvv options<br>Attachment 201244: Using a spinner instead of checkboxes</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/353903" target="_blank">353903</a></td>
		<td>13039 bytes</td>
		<td>"Function Callgraph" should use the most recently used launch config<br>Attachment 202772: Fill default configuration with the same attributes that are used by LaunchStapGraph</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Patrick&nbsp;Hofer (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/275685" target="_blank">275685</a></td>
		<td>1455 bytes</td>
		<td>[valgrind] doesn't launch on debian based system<br>Attachment 136783: proposed patch with copyright info</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Patrick&nbsp;Tasse (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/310709" target="_blank">310709</a></td>
		<td>11240 bytes</td>
		<td>[TMF] Time Analysis Viewer widget single event trace and fixed time interval problems<br>Attachment 166264:  Proposed patch on org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319428" target="_blank">319428</a></td>
		<td>16052 bytes</td>
		<td>[TMF] Generalization of Project View<br>Attachment 173913: Proposed patch in org.eclipse.linuxtools.tmf package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319428" target="_blank">319428</a></td>
		<td>228807 bytes</td>
		<td>[TMF] Generalization of Project View<br>Attachment 173914: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319429" target="_blank">319429</a></td>
		<td>332308 bytes</td>
		<td>[TMF] Implementation of Custom Parsers<br>Attachment 173916: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319429" target="_blank">319429</a></td>
		<td>4662 bytes</td>
		<td>[TMF] Implementation of Custom Parsers<br>Attachment 173917: Icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/325638" target="_blank">325638</a></td>
		<td>25209 bytes</td>
		<td>[TMF] Virtual Table widget improvements and bug fixes<br>Attachment 189654: Proposed patch on TmfVirtualTable.java and TmfEventsTable.java</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/327265" target="_blank">327265</a></td>
		<td>38018 bytes</td>
		<td>[TMF] Custom parsers NPE, extra columns and event type &amp; content fixes<br>Attachment 189648: Proposed patch in org.eclipse.linuxtools.tmf.ui</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/337857" target="_blank">337857</a></td>
		<td>9919 bytes</td>
		<td>[TMF] Refactoring of background requests<br>Attachment 189510: Proposed patch in org.eclipse.linuxtools.tmf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/337872" target="_blank">337872</a></td>
		<td>5981 bytes</td>
		<td>[TMF] Progress monitor feedback for indexing and constructor trigger<br>Attachment 189522: Proposed patch in org.eclipse.linuxtools.tmf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/337891" target="_blank">337891</a></td>
		<td>1699 bytes</td>
		<td>[TMF] Event clone erases content<br>Attachment 189538: Proposed patch in org.eclipse.linuxtools.tmf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/337900" target="_blank">337900</a></td>
		<td>5003 bytes</td>
		<td>[TMF] Buffered random access file<br>Attachment 189543: Proposed patch in org.eclipse.linuxtools.tmf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/337914" target="_blank">337914</a></td>
		<td>62765 bytes</td>
		<td>[TMF] Implementation of filter model<br>Attachment 189552: Proposed patch in org.eclipse.linuxtools.tmf package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/337914" target="_blank">337914</a></td>
		<td>11114 bytes</td>
		<td>[TMF] Implementation of filter model<br>Attachment 189558: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338016" target="_blank">338016</a></td>
		<td>80544 bytes</td>
		<td>[TMF] Consolidation of externalization strings<br>Attachment 189634: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338112" target="_blank">338112</a></td>
		<td>10339 bytes</td>
		<td>[TMF] Projects view improvements and bug fixes<br>Attachment 189709: Proposed patch in org.eclipse.linuxtools.tmf.ui.views.project package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338112" target="_blank">338112</a></td>
		<td>867 bytes</td>
		<td>[TMF] Projects view improvements and bug fixes<br>Attachment 189710: icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338151" target="_blank">338151</a></td>
		<td>71362 bytes</td>
		<td>[TMF] Implementation of Filters view<br>Attachment 189736: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338151" target="_blank">338151</a></td>
		<td>1975 bytes</td>
		<td>[TMF] Implementation of Filters view<br>Attachment 189737: icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338155" target="_blank">338155</a></td>
		<td>49208 bytes</td>
		<td>[TMF] Implementation of Colors view<br>Attachment 189748: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338155" target="_blank">338155</a></td>
		<td>512 bytes</td>
		<td>[TMF] Implementation of Colors view<br>Attachment 189749: icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338162" target="_blank">338162</a></td>
		<td>45556 bytes</td>
		<td>[TMF] Implementation of raw event viewer<br>Attachment 189754: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338162" target="_blank">338162</a></td>
		<td>3825 bytes</td>
		<td>[TMF] Implementation of raw event viewer<br>Attachment 189755: Proposed patch in org.eclipse.linuxtools.tmf package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338162" target="_blank">338162</a></td>
		<td>1219 bytes</td>
		<td>[TMF] Implementation of raw event viewer<br>Attachment 189756: Proposed patch in org.eclipse.linuxtools.tmf.tests package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338253" target="_blank">338253</a></td>
		<td>76166 bytes</td>
		<td>[TMF] Implementation of searching, filtering, highlighting and bookmarking in events table<br>Attachment 189836: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338253" target="_blank">338253</a></td>
		<td>1953 bytes</td>
		<td>[TMF] Implementation of searching, filtering, highlighting and bookmarking in events table<br>Attachment 189837: Proposed patch in org.eclipse.linuxtools.tmf package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/338253" target="_blank">338253</a></td>
		<td>2193 bytes</td>
		<td>[TMF] Implementation of searching, filtering, highlighting and bookmarking in events table<br>Attachment 189838: icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/342769" target="_blank">342769</a></td>
		<td>47389 bytes</td>
		<td>[TMF] Refactoring of event cache with filter support and optimization of GUI refresh<br>Attachment 193199: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/348000" target="_blank">348000</a></td>
		<td>5698 bytes</td>
		<td>[TMF] Filter viewer does not update with new custom parser fields<br>Attachment 197154: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/348010" target="_blank">348010</a></td>
		<td>849 bytes</td>
		<td>[TMF] NullPointerException in custom XML parser wizard<br>Attachment 197167: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/348020" target="_blank">348020</a></td>
		<td>3620 bytes</td>
		<td>[TMF] Color resource leak in Colors view<br>Attachment 197180: Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/353020" target="_blank">353020</a></td>
		<td>222892 bytes</td>
		<td>[TMF, LTTng] Changes for streaming support, background and event request refactoring, trace control updates and minor bug fixes<br>Attachment 200291: Proposed patch in org.eclipse.linuxtools packages</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Rafael&nbsp;Medeiros&nbsp;Teixeira (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=23a84d389e2475fd33c57784d4ec3b0f707aa952" target="_blank">23a84d</a></td>
		<td>165 lines</td>
		<td>Oprofile: Fix NPE after failed profile</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d0c56f56e038377e694988140a2c4cca556d35f" target="_blank">2d0c56</a></td>
		<td>30 lines</td>
		<td>Fixing bug with remote profiling when remote tools' connection name has whitespace characters</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=994a46cba9a92b3f657f5d9cb6447bde80c12725" target="_blank">994a46</a></td>
		<td>211 lines</td>
		<td>Minor fixes on profiling.launch.ui plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9bc82fd9c00ca95a2f14f3fa78ac18b3e2921402" target="_blank">9bc82f</a></td>
		<td>38 lines</td>
		<td>Fix for <a href="https://bugs.eclipse.org/333315" target="_blank">Bug 333315</a> - Add text to Valgrind view when no errors were found.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b976523cbb21e6b64b4c3ab25dcc0d28b411741c" target="_blank">b97652</a></td>
		<td>10 lines</td>
		<td>Further fix for <a href="https://bugs.eclipse.org/333315" target="_blank">Bug 333315</a>. Since the last fix doesn't allow empty</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cba9b8bec9ddc7834969f649c06d5cd675ae01d5" target="_blank">cba9b8</a></td>
		<td>197 lines</td>
		<td>oprofile: Modifications to use the linuxtools' path set for the project.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cccffee4b8128975dbad6d966e286147c08cdde2" target="_blank">cccffe</a></td>
		<td>27 lines</td>
		<td>oprofile: Edited ChangeLog, removed unnecessary import in 
OpInfo.java, removed version for 
org.eclipse.linuxtools.tools.launch.core in MANIFEST.MF</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5b4d2c098f6bc0fda0b132fe24edd989e923c05" target="_blank">e5b4d2</a></td>
		<td>131 lines</td>
		<td>Change RuntimeProcessFactory to use file and process proxies</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f3508856a3aee69b119dcdae382e3552853aa9f8" target="_blank">f35088</a></td>
		<td>1476 lines</td>
		<td>Oprofile: Added support for remote targets with Oprofile</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/315505" target="_blank">315505</a></td>
		<td>109236 bytes</td>
		<td>[remote] Support remote targets with OProfile<br>Attachment 217969: Patch to add support for remote targets with Oprofile</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/364941" target="_blank">364941</a></td>
		<td>26436 bytes</td>
		<td>Add support for multiple Oprofile launch configs<br>Attachment 208014: Patch to change Linux Tools path for Oprofile</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/364941" target="_blank">364941</a></td>
		<td>3880 bytes</td>
		<td>Add support for multiple Oprofile launch configs<br>Attachment 208016: Minor fixes</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/369766" target="_blank">369766</a></td>
		<td>17256 bytes</td>
		<td>Request to add a IRemoteFileProxy based file and directory chooser for use in launch configuration tabs<br>Attachment 216397: Minor fixes on profiling.launch.ui plugins</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/377120" target="_blank">377120</a></td>
		<td>15482 bytes</td>
		<td>Oprofile - Profiling fails when Linux Tools Path property is changed<br>Attachment 215987: Patch to fix NPE after failed Oprofile run with Linux Tools Path property set</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/381248" target="_blank">381248</a></td>
		<td>48896 bytes</td>
		<td>Request to add a new implementation of CMainTab using ResourceSelectorWidget<br>Attachment 216856: Patch to add RemoteProxyCMainTab</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/382060" target="_blank">382060</a></td>
		<td>26054 bytes</td>
		<td>Modify Remote Valgrind profile configuration tab group to use RemoteCMainTab<br>Attachment 217101: Patch that adds Valgrind Remote Tab Group that uses RemoteProxyCMainTab</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/383833" target="_blank">383833</a></td>
		<td>4601 bytes</td>
		<td>Unable to run remote profiling with RemoteProxyCMainTab using remote tools when connection name has a whitespace character<br>Attachment 218048: Fixing bug with remote profiling when remote tools' connection name has whitespace characters</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Rafael&nbsp;Peria&nbsp;de&nbsp;Sene (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47eeed4670e96cd506b2ba1860758d7c23bbd025" target="_blank">47eeed</a></td>
		<td>54 lines</td>
		<td>[linuxtools settings | <a href="https://bugs.eclipse.org/412003" target="_blank">Bug 412003</a>] - This commit includes the capability to change the ComboFieldEditor according the selected path</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Remy&nbsp;Suen (ca.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/179141" target="_blank">179141</a></td>
		<td>5531 bytes</td>
		<td>ChangeLog plug-in should migrate away from plugin.xml to MANIFEST.MF<br>Attachment 61889: Patch to remove stuff in plugin.xml and move them to a MANIFEST.MF file.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181249" target="_blank">181249</a></td>
		<td>4330 bytes</td>
		<td>Plug-ins do not specify execution environments and/or does not use OSGi manifests<br>Attachment 63087: Patch to fix up org.eclipse.linuxtools.rpm.core.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181249" target="_blank">181249</a></td>
		<td>1164 bytes</td>
		<td>Plug-ins do not specify execution environments and/or does not use OSGi manifests<br>Attachment 63088: Patch for org.eclipse.linuxtools.rpm.ui.editor.tests.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181249" target="_blank">181249</a></td>
		<td>1208 bytes</td>
		<td>Plug-ins do not specify execution environments and/or does not use OSGi manifests<br>Attachment 63091: Patch to update org.eclipse.linuxtools.rpm.ui.editors.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181249" target="_blank">181249</a></td>
		<td>3689 bytes</td>
		<td>Plug-ins do not specify execution environments and/or does not use OSGi manifests<br>Attachment 63116: Patch for org.eclipse.linuxtools.rpm.core.tests.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/181249" target="_blank">181249</a></td>
		<td>3858 bytes</td>
		<td>Plug-ins do not specify execution environments and/or does not use OSGi manifests<br>Attachment 63117: Patch to correct org.eclipse.linuxtools.rpm.ui.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Renato&nbsp;Stoffalette&nbsp;Joao (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a51b10e651b121b231794d5b46bc36b7c2425728" target="_blank">a51b10</a></td>
		<td>183 lines</td>
		<td>Some work to add javadoc to Oprofile Ui model</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce8794d35d256aad1eaefda71308dc54375320d2" target="_blank">ce8794</a></td>
		<td>410 lines</td>
		<td>This is a piechart implementation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce90211e38a814f01befb35086708cb7718295fd" target="_blank">ce9021</a></td>
		<td>1800 lines</td>
		<td>Renamed package org.eclipse.linuxtools.internal.oprofile.ui.model to org.eclipse.linuxtools.oprofile.ui.model</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb573b0faf4a0e6291832df8384c1096300c50dc" target="_blank">fb573b</a></td>
		<td>355 lines</td>
		<td>Initial work to add javadoc to Oprofile</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/373552" target="_blank">373552</a></td>
		<td>17516 bytes</td>
		<td>Switch Systemtap Charting from BIRT to using SWTChart<br>Attachment 214956: A piechart implementation extending Chart from SWTChart</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Rodrigo&nbsp;Fraxino&nbsp;Araujo (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=10b2ac23a9922c59f92b497d39c2d81653e0eff2" target="_blank">10b2ac</a></td>
		<td>883 lines</td>
		<td>Added support for remote perf using Linuxtools profiling package.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c10397fc9dfb87d647f54a6afb64f8e8ead9af4" target="_blank">1c1039</a></td>
		<td>236 lines</td>
		<td>Fixed duplicated events on remote perf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3463459b844bbbae9f68e9017b28f7f400ea8653" target="_blank">346345</a></td>
		<td>115 lines</td>
		<td>perf: fix for remote and sync perf after version update</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=365428e902048308e590fe8ee1615fcab32c3cbf" target="_blank">365428</a></td>
		<td>2 lines</td>
		<td>perf: Fix for remote testing.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=724bb1b4f2cb8f31a26b85f13a28f289e1e5c62d" target="_blank">724bb1</a></td>
		<td>4 lines</td>
		<td>valgrind: Fix project dir when verifying bin for sync projects</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=982ec65eee5a092d0dccbe9d785ada9bb7caf197" target="_blank">982ec6</a></td>
		<td>110 lines</td>
		<td>Fixed binary and working dir of main tab for sync projects</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a3d7513a987ab6bd6fe2d81c33581b4ee45ac10b" target="_blank">a3d751</a></td>
		<td>278 lines</td>
		<td>Added support for PTP sync projects in the RDT proxy. Added a</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b178c605f58fe9d56abfcfa2d6c98b95df079dbd" target="_blank">b178c6</a></td>
		<td>296 lines</td>
		<td>Added support to create and export RPM files remotely.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=caa8711868f24ae8ce46deebae32cf1bfc6d474d" target="_blank">caa871</a></td>
		<td>25 lines</td>
		<td>Fixed parsing RSE output of RuntimeProcessFactory.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f26acf161ea167b2c0d0d62925ca20769dda5678" target="_blank">f26acf</a></td>
		<td>6 lines</td>
		<td>Fix output of perf list when executed locally by redirecting its output directly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f39e900a79ca0a5c833ec657f36053b7cf04ba90" target="_blank">f39e90</a></td>
		<td>148 lines</td>
		<td>Fix directories path for rpmbuild and flat layout.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Rodrigo&nbsp;Fraxino&nbsp;Araujo (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/377671" target="_blank">377671</a></td>
		<td>18865 bytes</td>
		<td>Remote support for RPM plug-in<br>Attachment 214643: Patch to add remote support to RPM using linuxtools profiling package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/382882" target="_blank">382882</a></td>
		<td>56145 bytes</td>
		<td>Patch to add support for remote perf<br>Attachment 217961: patch for remote perf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/383552" target="_blank">383552</a></td>
		<td>2882 bytes</td>
		<td>RuntimeProcessFactory fails when using RSE<br>Attachment 218046: parse rse output of runtimeprocessfactory</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/383850" target="_blank">383850</a></td>
		<td>11121 bytes</td>
		<td>Local RPM always uses FLAT layout and remote RPM always uses RPMBUILD layout<br>Attachment 218114: fix path used by rpm export</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/383920" target="_blank">383920</a></td>
		<td>1439 bytes</td>
		<td>Perf hangs on creation of the Event Tab for local configuration<br>Attachment 218115: fix local execution of perf list</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/383936" target="_blank">383936</a></td>
		<td>12855 bytes</td>
		<td>Perf events tab is getting duplicated in remote profiling<br>Attachment 218109: fix duplicated events on remote perf.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Ryan&nbsp;Xu (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/360950" target="_blank">360950</a></td>
		<td>1205 bytes</td>
		<td>When open the preference page of valgrind on windows host, the whole eclipse will hang.<br>Attachment 205188: patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Sami&nbsp;Wagiaalla (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/341640" target="_blank">341640</a></td>
		<td>1642 bytes</td>
		<td>[eclipse-build] Using webkit on x86_64 on Fedora 15 causes a segfault and a crash<br>Attachment 192480: Add missing header file</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Severin&nbsp;Gehwolf (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/295098" target="_blank">295098</a></td>
		<td>1977 bytes</td>
		<td>[eclipse-build] 2 failures in org.eclipse.pde.ui.tests (x86_64; Fedora 12; 0.4RC5)<br>Attachment 172121: Patch which should fix testSourceFeatureBundleContainer failures</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/319742" target="_blank">319742</a></td>
		<td>965 bytes</td>
		<td>NPE: An internal error occurred during: "Update RPM packages proposal list"<br>Attachment 174532: Bugfix</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/321905" target="_blank">321905</a></td>
		<td>18360 bytes</td>
		<td>IMAGE_FILTER set incorrectly if project is external<br>Attachment 176246: Regression-test for this bug.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/327832" target="_blank">327832</a></td>
		<td>1579 bytes</td>
		<td>eclipse-build patch for prepare-build-dir.sh<br>Attachment 181733: Revised patch for prepare-build-dir.sh</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Simon&nbsp;Delisle (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a73ff18a683a73d6a89e12054747bdb79745892" target="_blank">0a73ff</a></td>
		<td>79 lines</td>
		<td>ctf: Fix formatting in CTFTrace</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=21dee3a16d574b343002df8702b72f19102555b7" target="_blank">21dee3</a></td>
		<td>536 lines</td>
		<td>LTTng: Support for LTTng Tools 2.2</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f6b9f3f1f0a33d046ef82c967f8d9feeb3c62b3" target="_blank">4f6b9f</a></td>
		<td>361 lines</td>
		<td>Tmf: Benchmark for the request scheduler</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=82d4e5fae2b1acb4becfc5d3360248eff9164937" target="_blank">82d4e5</a></td>
		<td>31 lines</td>
		<td>Ctf: add removeIterator() to prevent OutOfMemory exception (<a href="https://bugs.eclipse.org/414998" target="_blank">Bug 414998</a>)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=972869380c66a93ecb448be8b56afde4c9964ab5" target="_blank">972869</a></td>
		<td>150 lines</td>
		<td>Ctf: Callsite bug fix when position is negative (binarySearch)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e1c7f7c21ba73a52256bc0c515246fc9faae561" target="_blank">9e1c7f</a></td>
		<td>218 lines</td>
		<td>Formatting IOstructgenTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bd379f15ca418310bd9df91d75ff34c02e1bb3a6" target="_blank">bd379f</a></td>
		<td>129 lines</td>
		<td>ctf: Read and display custom event attributes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bfe021b226b3caa93ab836b793a9347641d39448" target="_blank">bfe021</a></td>
		<td>1 lines</td>
		<td>tmf: Add missing selected trace signal (fix #404682)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cac6bb9eb77a7329e78b43161438475723075127" target="_blank">cac6bb</a></td>
		<td>627 lines</td>
		<td>tmf: Introduce a scheduler for event requests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d7907a52f9d0420c6888b95625cb2780c868fc54" target="_blank">d7907a</a></td>
		<td>132 lines</td>
		<td>LTTng: Show the buffer type in the domain property view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb8fe6c1a5f167fecf38f2a24c4e4e2bd71daf2b" target="_blank">fb8fe6</a></td>
		<td>165 lines</td>
		<td>Generate trace in IOstructgenTest</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Simon&nbsp;Marchi (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81afd6cd8aa192455b5b9207f5fbcacaa3aca9fb" target="_blank">81afd6</a></td>
		<td>84 lines</td>
		<td>Add or fix CTF types toString</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=92b9d7d6f6ae06a8f9b4d465e6080c4b302a3859" target="_blank">92b9d7</a></td>
		<td>4 lines</td>
		<td>Fix EnumDefinition's "value" field assignments</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e91367a7f265278d60dbaf9cb7763a502c7bb66" target="_blank">9e9136</a></td>
		<td>100 lines</td>
		<td>Change from int to long for values that represent sizes in bit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=db55844a3ef6cc363d6d73c1e40fdfd379885588" target="_blank">db5584</a></td>
		<td>114 lines</td>
		<td>Add "check subtree" feature to TimeGraphFilterDialog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f16f88579e461dc603aeeb9c4d9b70d4c81a8069" target="_blank">f16f88</a></td>
		<td>157 lines</td>
		<td>Add multiple selection in the time graph filter dialog</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Stephen&nbsp;Shaw (decriptor.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9eea85dd783db3bb37a458f21365ffb4a9ffa7d0" target="_blank">9eea85</a></td>
		<td>82 lines</td>
		<td>Now accounts for jvm being in /usr/lib64 on 64bit machines</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/340174" target="_blank">340174</a></td>
		<td>17622 bytes</td>
		<td>[eclipse-build] Doesn't account for jvm being in /usr/lib64<br>Attachment 191309: Patch to fix this bug</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">The&nbsp;Written&nbsp;Word (vendor.thewrittenword.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/308247" target="_blank">308247</a></td>
		<td>16721 bytes</td>
		<td>Building Eclipse 3.5.2 with Sun JVM 1.6u19 requires jsse.jar in classpath<br>Attachment 163940: Patch to build.properties and pdebuild.properties</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/308267" target="_blank">308267</a></td>
		<td>1247 bytes</td>
		<td>/etc/eclipse.ini hardcoded in build.xml<br>Attachment 163962: New property, sysconfdir, defaulting to /etc, specifying where eclipse.ini should be installed.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Uwe&nbsp;Stieber (windriver.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/265494" target="_blank">265494</a></td>
		<td>632 bytes</td>
		<td>MacroProposalsPreferencePage fails to compile with Eclipse 3.5M5<br>Attachment 126187: Set the visibility of selectionChanged to protected</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/265495" target="_blank">265495</a></td>
		<td>1474 bytes</td>
		<td>oprofile linux x86 and x86_64 cannot find fragment host<br>Attachment 126188: Setting fragment host version constraint to 0.1.0 instead of 0.1</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Wainer&nbsp;S.&nbsp;Moschetta (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=01da97728da1670feb8d2db860b70ef6276f67a5" target="_blank">01da97</a></td>
		<td>202 lines</td>
		<td>systemtap: add more missing copyright headers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1a7656925a7933b2b85b78aa9a3f28eca5d0e964" target="_blank">1a7656</a></td>
		<td>165 lines</td>
		<td>systemtap: add some missing copyright headers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1ad5b184dad25305b7f98943810ebc98bf31ba19" target="_blank">1ad5b1</a></td>
		<td>10 lines</td>
		<td>Perf: read events list also from stderr</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1b8367cafb661e0167b48299acfcd88070dce780" target="_blank">1b8367</a></td>
		<td>102 lines</td>
		<td>Fix erroneous license headers for systemtap.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3ceff6ab55ed91637ddcb4233edb28c79a3a7ae4" target="_blank">3ceff6</a></td>
		<td>252 lines</td>
		<td>Remote proxy: add getEnv() method</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=63afc3c97a7df4ebf67662145f7b9b6d4af68038" target="_blank">63afc3</a></td>
		<td>9 lines</td>
		<td>Perf: refactoring on events parser. Fixes <a href="https://bugs.eclipse.org/367555" target="_blank">Bug 367555</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=696a34b44cd7f32b23ac96f04747724d5a4841e6" target="_blank">696a34</a></td>
		<td>15 lines</td>
		<td>valgrind: recovery from failure on Valgrind.Command.whichversion()</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d63d525a4e4e62c1701abd872bc549940f52a4b" target="_blank">6d63d5</a></td>
		<td>2 lines</td>
		<td>Perf: fix handler of single event selection</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6fb6b2d7a3f116648290d9ee7e277e718ed977cd" target="_blank">6fb6b2</a></td>
		<td>102 lines</td>
		<td>Fix erroneous license headers for systemtap.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f2fd09b7a58433e8bf8b50a8e8e5ee9d7134075b" target="_blank">f2fd09</a></td>
		<td>12 lines</td>
		<td>Massif: remote used to not work due error to genrate heap chart title</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb1815a62778569315afc3a9f4207b6e8a735674" target="_blank">fb1815</a></td>
		<td>11 lines</td>
		<td>Polishing Perf plug-in</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/351355" target="_blank">351355</a></td>
		<td>1372 bytes</td>
		<td>gprof: support 64-bit gmon files in ppc64<br>Attachment 199194: Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/366075" target="_blank">366075</a></td>
		<td>2918 bytes</td>
		<td>Polish Perf plug-in<br>Attachment 208110: Patch with cosmetic changes</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/366611" target="_blank">366611</a></td>
		<td>1888 bytes</td>
		<td>Perf: read events list also from stderr<br>Attachment 208332: Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/367555" target="_blank">367555</a></td>
		<td>3027 bytes</td>
		<td>Perf: use regex to parse events<br>Attachment 208804: Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/367625" target="_blank">367625</a></td>
		<td>1441 bytes</td>
		<td>Perf: fix handler of single event selection<br>Attachment 208844: Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/379258" target="_blank">379258</a></td>
		<td>3123 bytes</td>
		<td>Fix pie chart title in gprof/gcov<br>Attachment 215481: Patch to fix it</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Will (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/341621" target="_blank">341621</a></td>
		<td>3528 bytes</td>
		<td>oprofile: hangs on Parsing OProfile Data<br>Attachment 192368: decided it should be cleaned up a bit. purely aesthetic changes from previous patch.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">William&nbsp;Bourque (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/287745" target="_blank">287745</a></td>
		<td>52326 bytes</td>
		<td>[TMF] Switch to JUnit3<br>Attachment 153968: Convert org.eclipse.linuxtools.lttng.tests to junit3. </td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/290060" target="_blank">290060</a></td>
		<td>22134 bytes</td>
		<td>[LTTng] Add a HOWTO to integrate the C library<br>Attachment 148947: LTTv installation guide, in HTML format.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291662" target="_blank">291662</a></td>
		<td>8906 bytes</td>
		<td>[LTTng] Refactoring of the LTTng JNI<br>Attachment 150879: Patch to support moving (reading) on a single tracefile in a trace</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291662" target="_blank">291662</a></td>
		<td>15717 bytes</td>
		<td>[LTTng] Refactoring of the LTTng JNI<br>Attachment 150880: Modified unit test to support move (seek and read) on single tracefile.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291662" target="_blank">291662</a></td>
		<td>8342 bytes</td>
		<td>[LTTng] Refactoring of the LTTng JNI<br>Attachment 151737: Modified JniEvent to improve speed.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/291662" target="_blank">291662</a></td>
		<td>14753 bytes</td>
		<td>[LTTng] Refactoring of the LTTng JNI<br>Attachment 154529: "New way" to Add a "endTime" for a trace </td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292393" target="_blank">292393</a></td>
		<td>21548 bytes</td>
		<td>[LTTng] Improve search of a process within the State model<br>Attachment 150691: Implemented HashMap instead of a list for LttngProcessState</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/292393" target="_blank">292393</a></td>
		<td>7007 bytes</td>
		<td>[LTTng] Improve search of a process within the State model<br>Attachment 150692: Cchanges in FlowContainer and ResourceContainer to add debug and better "equals"</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Yufen&nbsp;Kuo (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/340341" target="_blank">340341</a></td>
		<td>15183 bytes</td>
		<td>[LTTng] Missing liblttngtrace format not handled gracefully at all<br>Attachment
 201426: patch to display error dialog when native trace library fails 
to load instead of displaying stack trace in console</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/354541" target="_blank">354541</a></td>
		<td>63158 bytes</td>
		<td>LTTng plugins requires to set LD_LIBRARY_PATH to point to the path of native parsing libraries<br>Attachment 201344: Patch to add UI to allow user to specify parser library path in new LTTng project wizard and project property</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/354541" target="_blank">354541</a></td>
		<td>11047 bytes</td>
		<td>LTTng plugins requires to set LD_LIBRARY_PATH to point to the path of native parsing libraries<br>Attachment 201363: patch to fix compilation issues in org.eclipse.linuxtools.lttng.tests plugin</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/354541" target="_blank">354541</a></td>
		<td>2945 bytes</td>
		<td>LTTng plugins requires to set LD_LIBRARY_PATH to point to the path of native parsing libraries<br>Attachment 201448: patch to enable Project-&gt;Properties main menu when LTTng project is selected in Lttng Projects View</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/354541" target="_blank">354541</a></td>
		<td>6035 bytes</td>
		<td>LTTng plugins requires to set LD_LIBRARY_PATH to point to the path of native parsing libraries<br>Attachment 202190: patch for runpath setting note on loader parser library</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Yuriy&nbsp;Vashchuk (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/311930" target="_blank">311930</a></td>
		<td>100553 bytes</td>
		<td>[LTTng] HistogramView : Make sure time interval are small enought in very long trace<br>Attachment 175526: The multi-trace bug correction and histogram view improvements</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/311930" target="_blank">311930</a></td>
		<td>36020 bytes</td>
		<td>[LTTng] HistogramView : Make sure time interval are small enought in very long trace<br>Attachment 178666: Patch corrections</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/315889" target="_blank">315889</a></td>
		<td>59146 bytes</td>
		<td>[LTTng] HistogramView improvements<br>Attachment 174163: Histogram patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/323503" target="_blank">323503</a></td>
		<td>13228 bytes</td>
		<td>[LTTng] Histogram View design and draw improvements<br>Attachment 177323: The Histogram design and draw corrections</td>
				</tr>
	</tbody></table>
<h2>Repositories</h2>
<p>The information contained in this log was generated by using commit information from the following repositories:</p>
<div style="padding-left: 2em"><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git" target="_blank">/gitroot/linuxtools/org.eclipse.linuxtools.eclipse-build.git</a></div>
<div style="padding-left: 2em"><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git" target="_blank">/gitroot/linuxtools/org.eclipse.linuxtools.git</a></div>
<p>
</p></div>
</div></form></body></html>