{"checks":{"bugzilla_create_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Create <a href=\"https:\/\/bugs.eclipse.org\/bugs\/enter_bug.cgi?product=Tracecompass\">URL<\/a> could be successfully fetched."],"value":"https:\/\/bugs.eclipse.org\/bugs\/enter_bug.cgi?product=Tracecompass"},"bugzilla_query_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Query <a href=\"https:\/\/bugs.eclipse.org\/bugs\/buglist.cgi?product=Tracecompass\">URL<\/a> could be successfully fetched."],"value":"https:\/\/bugs.eclipse.org\/bugs\/buglist.cgi?product=Tracecompass"},"build_url":{"desc":"Sends a get request to the given CI URL and looks at the headers in the response (200, 404..). Also checks if the URL is really a Hudson instance (through a call to its API).","results":["Failed: could not get CI URL []."],"value":""},"dev_list":{"desc":"Checks if the Dev ML URL can be fetched using a simple get query.","results":["OK: Dev ML <a href=\"https:\/\/dev.eclipse.org\/mailman\/listinfo\/tracecompass-dev\">URL<\/a> could be successfully fetched."],"value":"https:\/\/dev.eclipse.org\/mailman\/listinfo\/tracecompass-dev"},"documentation_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Documentation <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">URL<\/a> could be successfully fetched."],"value":"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides"},"download_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Download <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.3.0\/rcp\/\">URL<\/a> could be successfully fetched."],"value":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.3.0\/rcp\/"},"forums":{"desc":"Checks if the Forums URL can be fetched using a simple get query.","results":["OK. Forum [IRC Channel (irc:\/\/irc.oftc.net\/tracecompass)] correctly defined.","Failed: could not get $str URL [$url].","OK. Forum [Trace Compass Forums] correctly defined.","OK: Forum [Trace Compass Forums] <a href=\"http:\/\/eclipse.org\/forums\/eclipse.tracecompass\">URL<\/a> could be successfully fetched."],"value":"http:\/\/eclipse.org\/forums\/eclipse.tracecompass"},"gettingstarted_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Documentation <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass\/Development_Environment_Setup\">URL<\/a> could be successfully fetched."],"value":"https:\/\/wiki.eclipse.org\/Trace_Compass\/Development_Environment_Setup"},"mailing_lists":{"desc":"Checks if the Mailing lists URL can be fetched using a simple get query.","results":["Failed: no mailing list defined."]},"plan_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["Failed: no URL defined for plan."]},"proposal_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["Failed: no URL defined for proposal."]},"releases":{"desc":"Checks if the releases have been correctly filled.","results":["Failed. Review for [7.3.0] type [2] is [none] on [2022-03-16 00:00:00].","Failed. Review for [7.2.0] type [2] is [none] on [2021-12-15 00:00:00].","Failed. Review for [7.1.0] type [2] is [none] on [2021-09-15 00:00:00].","OK. Review for [7.0.0] is 'success'.","Failed. Review for [6.3.0] type [2] is [none] on [2021-03-17 00:00:00].","Failed. Review for [6.2.0] type [2] is [none] on [2020-12-16 00:00:00].","Failed. Review for [6.1.0] type [2] is [none] on [2020-09-16 00:00:00].","OK. Review for [6.0.0] is 'success'.","Failed. Review for [5.3.0] type [2] is [none] on [2020-03-18 00:00:00].","Failed. Review for [5.2.0] type [2] is [none] on [2019-12-18 00:00:00].","Failed. Review for [5.1.0] type [2] is [none] on [2019-09-18 00:00:00].","OK. Review for [5.0.0] is 'success'.","OK. Review for [4.3.0] is 'success'.","OK. Review for [4.2.0] is 'success'.","OK. Review for [4.1.0] is 'success'.","OK. Review for [4.0.0] is 'success'.","OK. Review for [3.3.0] is 'success'.","OK. Review for [3.2.0] is 'success'.","OK. Review for [3.1.0] is 'success'.","OK. Review for [3.0.0] is 'success'.","OK. Review for [2.3.0] is 'success'.","OK. Review for [2.2.0] is 'success'.","OK. Review for [2.1.0] is 'success'.","OK. Review for [2.0.0] is 'success'.","OK. Review for [1.2.0] is 'success'.","OK. Review for [1.1.0] is 'success'.","OK. Review for [1.0.0] is 'success'.","OK. Review for [0.1.0] is 'success'."]},"source_repo":{"desc":"Checks if the Source repositories are filled and can be fetched using a simple get query.","results":["OK. Source repo [tracecompass\/org.eclipse.tracecompass] type [git] path [\/gitroot\/tracecompass\/org.eclipse.tracecompass.git].","OK: Source repo [tracecompass\/org.eclipse.tracecompass] <a href=\"https:\/\/git.eclipse.org\/r\/plugins\/gitiles\/tracecompass\/org.eclipse.tracecompass\">URL<\/a> could be successfully fetched."],"value":"https:\/\/git.eclipse.org\/r\/plugins\/gitiles\/tracecompass\/org.eclipse.tracecompass"},"title":{"desc":"Checks if a name is defined for the project: !~ m!^\\s*$!","results":["OK"],"value":"Eclipse Trace Compass™"},"update_sites":{"desc":"Checks if the update sites can be fetched using a simple get query.","results":["OK. Update site [Release 7.3.0] has title.","OK: Update site [Release 7.3.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.3.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 7.2.0] has title.","OK: Update site [Release 7.2.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.2.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 7.1.0] has title.","OK: Update site [Release 7.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 7.0.0] has title.","OK: Update site [Release 7.0.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.0.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 6.3.0] has title.","OK: Update site [Release 6.3.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.3.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 6.2.1] has title.","OK: Update site [Release 6.2.1] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.2.1\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 6.2.0] has title.","OK: Update site [Release 6.2.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.2.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 6.1.0] has title.","OK: Update site [Release 6.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 6.0.0] has title.","OK: Update site [Release 6.0.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.0.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 5.3.0] has title.","OK: Update site [Release 5.3.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.3.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 5.2.0] has title.","OK: Update site [Release 5.2.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.2.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 5.1.0] has title.","OK: Update site [Release 5.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 5.0.0] has title.","OK: Update site [Release 5.0.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.0.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 4.3.0] has title.","OK: Update site [Release 4.3.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.3.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 4.2.0] has title.","OK: Update site [Release 4.2.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.2.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 4.1.0] has title.","OK: Update site [Release 4.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 4.0.0] has title.","OK: Update site [Release 4.0.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.0.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 3.3.0] has title.","OK: Update site [Release 3.3.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.3.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 3.2.0] has title.","OK: Update site [Release 3.2.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.2.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 3.1.0] has title.","OK: Update site [Release 3.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 3.0.0] has title.","OK: Update site [Release 3.0.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.0.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 2.3.0] has title.","OK: Update site [Release 2.3.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.3.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 2.2.0] has title.","OK: Update site [Release 2.2.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.2.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 2.1.0] has title.","OK: Update site [Release 2.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 2.0.1] has title.","OK: Update site [Release 2.0.1] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.0.1\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 2.0.0] has title.","OK: Update site [Release 2.0.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.0.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 1.2.1] has title.","OK: Update site [Release 1.2.1] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.2.1\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 1.2.0] has title.","OK: Update site [Release 1.2.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.2.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 1.1.0] has title.","OK: Update site [Release 1.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 1.0.0] has title.","OK: Update site [Release 1.0.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.0.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Release 0.1.0] has title.","OK: Update site [Release 0.1.0] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/releases\/0.1.0\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Latest stable builds] has title.","OK: Update site [Latest stable builds] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/stable\/repository\/\">URL<\/a> could be successfully fetched.","OK. Update site [Nightly] has title.","OK: Update site [Nightly] <a href=\"http:\/\/download.eclipse.org\/tracecompass\/master\/repository\/\">URL<\/a> could be successfully fetched."],"value":"http:\/\/download.eclipse.org\/tracecompass\/master\/repository\/"},"website_url":{"desc":"Checks if the URL can be fetched using a simple get query.","results":["OK: Website <a href=\"https:\/\/www.eclipse.org\/tracecompass\/\">URL<\/a> could be successfully fetched."],"value":"https:\/\/www.eclipse.org\/tracecompass\/"},"wiki_url":{"desc":"Sends a get request to the project wiki URL and looks at the headers in the response (200, 404..).","results":["OK: Wiki <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass\">URL<\/a> could be successfully fetched."],"value":"https:\/\/wiki.eclipse.org\/Trace_Compass"}},"id_pmi":"tools.tracecompass","last_update":1650763227,"name":"Eclipse Trace Compass™","pmi":{"bugzilla":[{"component":"","create_url":"https:\/\/bugs.eclipse.org\/bugs\/enter_bug.cgi?product=Tracecompass","product":"Tracecompass","query_url":"https:\/\/bugs.eclipse.org\/bugs\/buglist.cgi?product=Tracecompass"}],"build_description":[],"build_doc":[],"build_technologies":[{"tid":"962"},{"tid":"7"},{"tid":"6"}],"build_url":[{}],"contrib_message":[{"format":"full_html","safe_value":"<p>To download the Trace Compass source code, clone the following git repo:<\/p>\n<p>$ git clone git:\/\/git.eclipse.org\/gitroot\/tracecompass\/org.eclipse.tracecompass.git<\/p>\n<p>See the README file for build instructions.<\/p>\n<p> <\/p>\n<p>If you wish to import the source plugins into Eclipse to work on them, see the Development Environment Setup guide.<\/p>\n<p>If you then wish to contribute patches, please take a look at the contributor guidelines.<\/p>\n<p>Static code analysis of the Trace Compass code is available at Coverity and Eclipse SonarQube server.<\/p>\n<p> <\/p>\n","value":"<p>To download the Trace Compass source code, clone the following git repo:<\/p>\r\n\r\n<p>$ git clone git:\/\/git.eclipse.org\/gitroot\/tracecompass\/org.eclipse.tracecompass.git<\/p>\r\n\r\n<p>See the README file for build instructions.<\/p>\r\n\r\n<p>&nbsp;<\/p>\r\n\r\n<p>If you wish to import the source plugins into Eclipse to work on them, see the Development Environment Setup guide.<\/p>\r\n\r\n<p>If you then wish to contribute patches, please take a look at the contributor guidelines.<\/p>\r\n\r\n<p>Static code analysis of the Trace Compass code is available at Coverity and Eclipse SonarQube server.<\/p>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"contributors":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p><strong><em>Eclipse Trace Compass<\/em><\/strong>™ is an open source application to solve performance and reliability issues by reading and analyzing logs or traces of a system. Its goal is to provide views, graphs, metrics, and more to help extract useful information from traces, in a way that is more user-friendly and informative than huge text dumps.<\/p>\n<p>More details about Trace Compass can be found here.<\/p>\n","summary":"","value":"<p><strong><em>Eclipse Trace Compass<\/em><\/strong>&trade; is an open source application to solve performance and reliability issues by reading and analyzing logs or traces of a system. Its goal is to provide views, graphs, metrics, and more to help extract useful information from traces, in a way that is more user-friendly and informative than huge text dumps.<\/p>\r\n\r\n<p>More details about Trace Compass can be found here.<\/p>\r\n"}],"dev_list":{"email":"ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o","name":"tracecompass-dev","url":"https:\/\/dev.eclipse.org\/mailman\/listinfo\/tracecompass-dev"},"documentation":[],"documentation_url":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides"}],"download_url":[{"attributes":[],"title":null,"url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.3.0\/rcp\/"}],"downloads":[{"attributes":[],"title":"Trace Compass RCP 7.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.3.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 7.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.2.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 7.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.1.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 7.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.0.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 6.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.3.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 6.2.1","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.2.1\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 6.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.2.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 6.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.1.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 6.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.0.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 5.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.3.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 5.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.2.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 5.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.1.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 5.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.0.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 4.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.3.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 4.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.2.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 4.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.1.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 4.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.0.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 3.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.3.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 3.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.2.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 3.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.1.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 3.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.0.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 2.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.3.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 2.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.2.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 2.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.1.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 2.0.1","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.0.1\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 2.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.0.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 1.2.1","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.2.1\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 1.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.1.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 1.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.0.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 1.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.2.0\/rcp\/"},{"attributes":[],"title":"Trace Compass RCP 0.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/0.1.0\/rcp\/"},{"attributes":[],"title":"Stable RCP builds","url":"http:\/\/download.eclipse.org\/tracecompass\/stable\/rcp\/"},{"attributes":[],"title":"Nightly RCP builds","url":"http:\/\/download.eclipse.org\/tracecompass\/master\/rcp\/"}],"downloads_message":[{"format":"full_html","safe_value":"<p>All downloads are provided under the terms and conditions of the Eclipse Foundation Software User Agreement unless otherwise specified.<\/p>\n<p>Trace Compass can be installed into an existing Eclipse using the \"Install New Software...\" dialog and entering the p2 repository URLs listed below.<\/p>\n<p>Trace Compass is also available as a stand-alone RCP application and can be downloaded from the download URLs below.<\/p>\n<p>The New &amp; Noteworthy for the releases can be found here.<\/p>\n<p><strong>Please note that starting with release 6.1.0 Trace Compass requires Java 11 to run.<\/strong><\/p>\n","value":"<p>All downloads are provided under the terms and conditions of the Eclipse Foundation Software User Agreement unless otherwise specified.<\/p>\r\n\r\n<p>Trace Compass can be installed into an existing Eclipse using the &quot;Install New Software...&quot; dialog and entering the p2 repository URLs listed below.<\/p>\r\n\r\n<p>Trace Compass is also available as a stand-alone RCP application and can be downloaded from the download URLs below.<\/p>\r\n\r\n<p>The New &amp; Noteworthy for the releases can be found here.<\/p>\r\n\r\n<p><strong>Please note that starting with release 6.1.0 Trace Compass requires Java 11 to run.<\/strong><\/p>\r\n"}],"forums":[{"description":"#tracecompass on irc.oftc.net","name":"IRC Channel (irc:\/\/irc.oftc.net\/tracecompass)","url":"irc:\/\/irc.oftc.net\/tracecompass"},{"description":"","name":"Trace Compass Forums","url":"http:\/\/eclipse.org\/forums\/eclipse.tracecompass"}],"gettingstarted_url":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/Development_Environment_Setup"}],"github_repos":[],"gitlab_repos":[],"id":[{"format":null,"safe_value":"tools.tracecompass","value":"tools.tracecompass"}],"ip_due_diligence_type":[],"licenses":[{"name":"Eclipse Public License 2.0","url":"http:\/\/www.eclipse.org\/legal\/epl-2.0"}],"logo":[{"alt":"","fid":"397","filemime":"image\/png","filename":"tclogo.png","filesize":"10421","height":"116","rdf_mapping":[],"status":"1","timestamp":"1417936497","title":"","uid":"119","uri":"public:\/\/tclogo.png","width":"200"}],"mailing_lists":[],"marketplace":[{"attributes":[],"title":"Trace Compass 7.3.0","url":"https:\/\/marketplace.eclipse.org\/content\/trace-compass"}],"other_links":[{"attributes":[],"title":"Test Reports","url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/TestReports"},{"attributes":[],"title":"Static Analysis (Coverity)","url":"https:\/\/scan.coverity.com\/projects\/tracecompass"},{"attributes":[],"title":"Static Analysis (SonarQube)","url":"https:\/\/dev.eclipse.org\/sonar\/dashboard\/index\/org.eclipse.tracecompass:org.eclipse.tracecompass"}],"parent_project":[{"id":"tools"}],"patent_license":[],"plan_url":[{}],"pmi_url":"https:\/\/projects.eclipse.org\/json\/project\/tools.tracecompass","proposal_url":[{}],"related":[],"releases":[{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2022-06-15 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 8.0.0 is a major release with API breakage, new features, and bug fixes.<\/p>\n<p>This release will be part of the Eclipse 2022-06 release.<\/p>\n","summary":"","value":"<p>Trace Compass 8.0.0 is a major release with API breakage, new features, and bug fixes.<\/p>\r\n\r\n<p>This release will be part of the Eclipse 2022-06 release.<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn80"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"8.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/8.0.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2022-03-16 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn73"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"7.3.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/7.3.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-12-15 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn72"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"7.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/7.2.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-09-15 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn71"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"7.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/7.1.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-06-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 7.0.0 is a major release with API breakage, new features, and bug fixes. <\/p>\n<p>This release will be part of the Eclipse 2021-06 release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass 7.0.0 is a major release with API breakage, new features, and bug fixes. <\/span><\/span><\/p>\r\n\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">This release will be part of the Eclipse 2021-06<\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn70"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2021-06-02 00:00:00"}],"links":[{"attributes":[],"title":"GitLab tracking issue","url":"https:\/\/gitlab.eclipse.org\/eclipsefdn\/emo-team\/emo\/-\/issues\/35"}],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"7.0.0"}],"state":[{"value":"success"}],"title":"7.0.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/7.0.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"7.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/7.0.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-03-17 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 6.3.0 is a minor release that will be part of the Eclipse 2021-03 release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 6.3.0 is a minor release that will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">2021-03<\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn63"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"6.3.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/6.3.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2021-01-14 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 6.2.1 is a bugfix only release. No new functionality is planned for this release.<\/p>\n","summary":"","value":"<p>Trace Compass 6.2.1 is a bugfix only release. No new functionality is planned for this release.<\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn621"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"6.2.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/6.2.1","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-12-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 6.2.0 is a minor release that will be part of the Eclipse 2020-12 release.<\/p>\n","summary":"","value":"<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 6.2.0 is a minor release that will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">2020-12<\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn62"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"6.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/6.2.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-09-16 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 6.1.0 is a minor release that will be part of the Eclipse 2020-09 release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 6.1.0 is a minor release that will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">2020-09<\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn61"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"6.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/6.1.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-06-17 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 6.0.0 is a major release with API breakage, new features, and bug fixes. <\/p>\n<p>This release will be part of the Eclipse 2020-06 release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass 6.0.0 is a major release with API breakage, new features, and bug fixes. <\/span><\/span><\/p>\r\n\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">This release will be part of the Eclipse 2020-06<\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn60"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2020-06-17 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"6.0.0"}],"state":[{"value":"success"}],"title":"6.0.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/6.0.0-release-review"},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"6.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/6.0.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2020-03-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 5.3.0 is a minor release that will be part of the Eclipse 2020-03 release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 5.3.0 is a minor release that will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">2020-03<\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn53"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.3.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/5.3.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-12-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 5.2.0 is a minor release that will be part of the Eclipse 2019-12 release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 5.2.0 is a minor release that will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">2019-12<\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn52"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/5.2.0","usability":[]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-09-18 00:00:00"}],"deliverables":[],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 5.1.0 is a minor release that will be part of the Eclipse 2019-09 release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 5.1.0 is a minor release that will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">2019-09<\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn51"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"5.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/5.1.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>There are no architectural issues.<\/p>\n","value":"<p>There are no architectural issues.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>6 active committers from 2 different organizations, 1 unaffiliated<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\">Automated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Trace Compass was part of the <a href=\"https:\/\/amdls.dorsal.polymtl.ca\/system\/files\/Trace%20Compass%20-%20Progress%20Report%20Meeting%20May%202019.pdf\">progress report meeting<\/a>, May 6-7, 2019<\/p>\n<\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">6 active committers from 2 different organizations, 1 unaffiliated<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">A<\/span><\/span>utomated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass was part of the <a href=\"https:\/\/amdls.dorsal.polymtl.ca\/system\/files\/Trace%20Compass%20-%20Progress%20Report%20Meeting%20May%202019.pdf\">progress report meeting<\/a>, May 6-7, 2019<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>The Trace Compass 5.0.0 major release removes APIs that had been deprecated for at least 1 release cycle. Tools extending Trace Compass need to align with the updated and removed APIs when upgrading to Trace Compass 5.0.0.<\/p>\n","value":"<p>The Trace Compass 5.0.0 major release removes APIs that had been deprecated for at least 1 release cycle. Tools extending Trace Compass need to align with the updated and removed APIs when upgrading to Trace Compass 5.0.0.<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-06-19 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 5.0.0 focuses on new features and bug fixes. API clean up was done and new APIs have been added as well. New features include:<\/p>\n<ul><li>Time graph improvements\n<ul><li>Zoom to selection<\/li>\n<li>Line entries<\/li>\n<\/ul><\/li>\n<li>XY Chart improvements\n<ul><li>Added keyboard navigation<\/li>\n<li>Added toolbar buttons<\/li>\n<\/ul><\/li>\n<li>Configurable time format for time axis<\/li>\n<li>Tooltip improvements\n<ul><li>Selectable and resizable tooltip<\/li>\n<li>Browser tooltip<\/li>\n<li>Tooltip information for markers<\/li>\n<\/ul><\/li>\n<li>System Calls categorized by component<\/li>\n<\/ul>","value":"<p>Trace Compass 5.0.0 focuses on new features and bug fixes. API clean up was done and new APIs have been added as well. New features include:<\/p>\r\n\r\n<ul>\r\n\t<li>Time graph improvements\r\n\t<ul>\r\n\t\t<li>Zoom to selection<\/li>\r\n\t\t<li>Line entries<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>XY Chart improvements\r\n\t<ul>\r\n\t\t<li>Added keyboard navigation<\/li>\r\n\t\t<li>Added toolbar buttons<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Configurable time format for time axis<\/li>\r\n\t<li>Tooltip improvements\r\n\t<ul>\r\n\t\t<li>Selectable and resizable tooltip<\/li>\r\n\t\t<li>Browser tooltip<\/li>\r\n\t\t<li>Tooltip information for markers<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>System Calls categorized by component<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 5.0.0 is a major release with API breakage, new features, and bug fixes. <\/p>\n<p>This release will be part of the Eclipse <a href=\"https:\/\/projects.eclipse.org\/releases\/2019-06\">2019-06<\/a> release.<\/p>\n","summary":"","value":"<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass 5.0.0 is a major release with API breakage, new features, and bug fixes. <\/span><\/span><\/p>\r\n\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">This release will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/projects.eclipse.org\/releases\/2019-06\">2019-06<\/a><\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn50"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2019-06-19 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"5.0.0"}],"state":[{"value":"success"}],"title":"5.0.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/5.0.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"5.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/5.0.0","usability":[{"format":"full_html","safe_value":"<p>In this release, the time format of the time axis is made configurable in accordance with the <strong>Date and Time format<\/strong> preference in the <strong>Time Format<\/strong> preference page. The time format in some views and charts could therefore be changed dependent on the preference when the user upgrades to version 5.0.0.<\/p>\n","value":"<p>In this release, the time format of the time axis is made configurable in accordance with the <strong>Date and Time format<\/strong> preference in the <strong>Time Format<\/strong> preference page. The time format in some views and charts could therefore be changed dependent on the preference when the user upgrades to version 5.0.0.<\/p>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 4.2\/2018-12 update release. <\/p>\n<p>There are no architectural changes for the core framework.<\/p>\n","value":"<p>The release is a small increment of our previous 4.2\/2018-12 update release.&nbsp;<\/p>\r\n\r\n<p>There are no architectural changes for the core framework.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>6 active committers from 2 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\">Automated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Trace Compass was part of the <a href=\"https:\/\/amdls.dorsal.polymtl.ca\/system\/files\/Progress%20Report%20Meeting%20Dec%202018.pdf\">progress report meeting<\/a>, December 6-7, 2018<\/p>\n<\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">6 active committers from 2 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">A<\/span><\/span>utomated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass was part of the <a href=\"https:\/\/amdls.dorsal.polymtl.ca\/system\/files\/Progress%20Report%20Meeting%20Dec%202018.pdf\">progress report meeting<\/a>, December 6-7, 2018<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>New APIs have been added to support new features.<\/p>\n","value":"<p>New APIs have been added to support new features.<\/p>\r\n"}],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2019-03-20 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 4.3.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\n<ul><li>Support for context TID and PID aspects<\/li>\n<li>Export experiments<\/li>\n<li>Improve system calls labels<\/li>\n<li>Export LAMI analyses results<\/li>\n<li>Add XML data driven error messages to the Error View<\/li>\n<li>Add properties for traces<\/li>\n<\/ul>","value":"<p>Trace Compass 4.3.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\r\n\r\n<ul>\r\n\t<li>Support for context TID and PID aspects<\/li>\r\n\t<li>Export experiments<\/li>\r\n\t<li>Improve system calls labels<\/li>\r\n\t<li>Export LAMI analyses results<\/li>\r\n\t<li>Add XML data driven error messages to the Error View<\/li>\r\n\t<li>Add properties for traces<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 4.3.0 is a minor release that will be part of the Eclipse <a href=\"https:\/\/projects.eclipse.org\/releases\/2019-03\">2019-03<\/a> release.<\/p>\n","summary":"","value":"<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<div class=\"field field-label-hidden field-name-body field-type-text-with-summary\">\r\n<div class=\"field-items\">\r\n<div class=\"even field-item\">\r\n<p><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 4.3.0 is a minor release that will be part of the Eclipse&nbsp;<\/span><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/projects.eclipse.org\/releases\/2019-03\">2019-03<\/a><\/span><\/span><span style=\"color:#333333; font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\"> release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn43"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2019-03-06 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"4.3.0"}],"state":[{"value":"success"}],"title":"4.3.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/4.3.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>No known security issues<\/p>\n","value":"<p>No known security issues<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"4.3.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/4.3.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 4.1.0\/2012-09 update release. <\/p>\n<p>There are no architectural changes for the core framework.<\/p>\n","value":"<p>The release is a small increment of our previous 4.1.0\/2012-09 update release.&nbsp;<\/p>\r\n\r\n<p>There are no architectural changes for the core framework.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>6 active committers from 2 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\">Automated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Trace Compass was part of the following talks:<\/p>\n<ul><li>\n<p>  LISA18 | USENIX Conference, October 29 - 31, 2018.<\/p>\n<ul><li>\n<p><a href=\"https:\/\/www.usenix.org\/conference\/lisa18\/presentation\/sharma-1\">Systems Tracing and Trace Visualization - Part 1<\/a><\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/www.usenix.org\/conference\/lisa18\/presentation\/sharma-2\">Systems Tracing and Trace Visualization - Part 2<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Trace Summit, October 25, 2018<\/p>\n<ul><li>\n<p><a href=\"https:\/\/tracingsummit.org\/wiki\/TracingSummit2018\">Tracing Summit Wiki Page<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>EclipseCon October 23-25, 2018<\/p>\n<ul><li>\n<p><a href=\"https:\/\/www.eclipsecon.org\/sites\/default\/files\/slides\/EclipseConEurope2018-Talk.pdf\">Trace Compass Past Present Future<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">6 active committers from 2 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">A<\/span><\/span>utomated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass was part of the following talks:<\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">&nbsp; LISA18 | USENIX Conference, October 29 - 31, 2018.<\/span><\/span><\/p>\r\n\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t<p><a href=\"https:\/\/www.usenix.org\/conference\/lisa18\/presentation\/sharma-1\">Systems Tracing and Trace Visualization - Part 1<\/a><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t<p><a href=\"https:\/\/www.usenix.org\/conference\/lisa18\/presentation\/sharma-2\">Systems Tracing and Trace Visualization - Part 2<\/a><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p>Trace Summit, October 25, 2018<\/p>\r\n\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t<p><a href=\"https:\/\/tracingsummit.org\/wiki\/TracingSummit2018\">Tracing Summit Wiki Page<\/a><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p>EclipseCon October 23-25, 2018<\/p>\r\n\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t<p><a href=\"https:\/\/www.eclipsecon.org\/sites\/default\/files\/slides\/EclipseConEurope2018-Talk.pdf\">Trace Compass Past Present Future<\/a><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>New APIs have been added to support new features<\/p>\n<p>32 bits Windows support has been removed.<\/p>\n","value":"<p>New APIs have been added to support new features<\/p>\r\n\r\n<p>32 bits Windows support has been removed.<\/p>\r\n"}],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-12-19 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 4.2.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\n<ul><li>Improved support for dark theme<\/li>\n<li>Potential memory leak detector\n<ul><li>Show non deallocated memory<\/li>\n<\/ul><\/li>\n<li>Support default zoom per trace type preference<\/li>\n<li>APIs to support traces in JSON format<\/li>\n<li>Data Driven XML analysis description improvements\n<ul><li>Support segment timing description (start time, end time, duration) in XML<\/li>\n<\/ul><\/li>\n<li>Critical Path improvements<\/li>\n<\/ul>","value":"<p>Trace Compass 4.2.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\r\n\r\n<ul>\r\n\t<li>Improved support for dark theme<\/li>\r\n\t<li>Potential memory leak detector\r\n\t<ul>\r\n\t\t<li>Show non deallocated memory<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Support default zoom per trace type preference<\/li>\r\n\t<li>APIs to support traces in JSON format<\/li>\r\n\t<li>Data Driven XML analysis description improvements\r\n\t<ul>\r\n\t\t<li>Support segment timing description (start time, end time, duration) in XML<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Critical Path improvements<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 4.2 is a minor release with new features, and bug fixes.<\/p>\n<p>This release will be part of <a href=\"https:\/\/projects.eclipse.org\/releases\/2018-12\">2018-12<\/a><\/p>\n","summary":"","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass 4.2 is a minor release with new features, and bug fixes.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">This release will be part of <a href=\"https:\/\/projects.eclipse.org\/releases\/2018-12\">2018-12<\/a><\/span><\/span><\/p>\r\n"}],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn42"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2018-12-19 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"4.2.0"}],"state":[{"value":"success"}],"title":"4.2.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/4.2.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>XML transformers security has been enforced. No known security issues.<\/p>\n","value":"<p>XML transformers security has been enforced. No known security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"4.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/4.2.0","usability":[{"format":"full_html","safe_value":"<p>Support for the Eclipse dark theme has been improved. It is now also possible to customize the default zoom level per type of trace using preference settings.<\/p>\n","value":"<p>Support for the Eclipse dark theme has been improved. It is now also possible to customize the default zoom level per type of trace using preference settings.<\/p>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 4.0.0\/Photon release. <\/p>\n<p>There are no architectural changes for the core framework.<\/p>\n<p> <\/p>\n","value":"<p>The release is a small increment of our previous 4.0.0\/Photon release.&nbsp;<\/p>\r\n\r\n<p>There are no architectural changes for the core framework.<\/p>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>6 active committers from 2 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\">Automated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul><p> <\/p>\n","value":"<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">6 active committers from 2 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">A<\/span><\/span>utomated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>New APIs have been added to support new features<\/p>\n","value":"<p>New APIs have been added to support new features<\/p>\r\n"}],"conf_ui_guidelines":[{"value":"not_verified"}],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-09-19 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 4.1.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\n<ul><li>Filtering improvements\n<ul><li>Follow thread in the Resources View<\/li>\n<\/ul><\/li>\n<li>Time graph improvements\n<ul><li>Allow navigation on both the X axis and Y axis simultaneously<\/li>\n<\/ul><\/li>\n<li>Improved time graph navigation<\/li>\n<li>Support for adding symbols to markers<\/li>\n<li>Simplified XML analysis label<\/li>\n<li>Trace trimming for experiments<\/li>\n<\/ul>","value":"<p>Trace Compass 4.1.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\r\n\r\n<ul>\r\n\t<li>Filtering improvements\r\n\t<ul>\r\n\t\t<li>Follow thread in the Resources View<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Time graph improvements\r\n\t<ul>\r\n\t\t<li>Allow navigation on both the X axis and Y axis simultaneously<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Improved time graph navigation<\/li>\r\n\t<li>Support for adding symbols to markers<\/li>\r\n\t<li>Simplified XML analysis label<\/li>\r\n\t<li>Trace trimming for experiments<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 4.1 is a minor release with new features, and bug fixes.<\/p>\n<p>This release will be part of <a href=\"https:\/\/projects.eclipse.org\/releases\/2018-09\">2018-09<\/a><\/p>\n","summary":"","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass 4.1 is a minor release with new features, and bug fixes.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">This release will be part of <a href=\"https:\/\/projects.eclipse.org\/releases\/2018-09\">2018-09<\/a><\/span><\/span><\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n","value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn41"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2018-09-05 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"4.1.0"}],"state":[{"value":"success"}],"title":"4.1.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/4.1.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"4.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/4.1.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>New plugins has been introduced<\/p>\n<p>Some provisionnal API has been officially published<\/p>\n","value":"<p>New plugins has been introduced<\/p>\r\n\r\n<p>Some provisionnal API has been officially published<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>6 active committers from 2 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\">Automated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul><p> <\/p>\n","value":"<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">6 active committers from 2 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><a href=\"http:\/\/amdls.dorsal.polymtl.ca\/\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">A<\/span><\/span>utomated monitoring and debugging of large scale manycore heterogeneous systems<\/a><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>The Trace Compass 4.0.0 major release removes APIs that had been deprecated for are at least 1 release cycle. Tools extending Trace Compass need to align with the updated and removed APIs when upgrading to Trace Compass 4.0.0.<\/p>\n<p>This release is part of the <a href=\"https:\/\/projects.eclipse.org\/releases\/photon\">Photon<\/a> Eclipse simultaneous release.<\/p>\n<p> <\/p>\n","value":"<p>The Trace Compass 4.0.0 major release removes APIs that had been deprecated for are at least 1 release cycle. Tools extending Trace Compass need to align with the updated and removed APIs when upgrading to Trace Compass 4.0.0.<\/p>\r\n\r\n<p>This release is part of the <a href=\"https:\/\/projects.eclipse.org\/releases\/photon\">Photon<\/a> Eclipse simultaneous release.<\/p>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-06-27 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 4.0.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\n<ul><li>Time events highlighting and filtering<\/li>\n<li>Resources view enhancements\n<ul><li>Resources view shows active threads<\/li>\n<li>Resources view shows CPU frequency when available<\/li>\n<\/ul><\/li>\n<li>CTF trace trimming<\/li>\n<li>Enabling and disabling XML analysis file<\/li>\n<li>Auto fit of columns in the events table<\/li>\n<\/ul>","value":"<p>Trace Compass 4.0.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\r\n\r\n<ul>\r\n\t<li>Time events highlighting and filtering<\/li>\r\n\t<li>Resources view enhancements\r\n\t<ul>\r\n\t\t<li>Resources view shows active threads<\/li>\r\n\t\t<li>Resources view shows CPU frequency when available<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>CTF trace trimming<\/li>\r\n\t<li>Enabling and disabling XML analysis file<\/li>\r\n\t<li>Auto fit of columns in the events table<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 4.0 is a major release with API breakage, new features, and bug fixes. <\/p>\n<p>This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/photon\">Photon<\/a>.<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n<div class=\"field-items\">\r\n<div class=\"field-item even\">\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass 4.0 is a major release with API breakage, new features, and bug fixes. <\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/photon\">Photon<\/a>.<\/span><\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n","value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn40"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2018-06-20 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"4.0.0"}],"state":[{"value":"success"}],"title":"4.0.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/4.0.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"4.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/4.0.0","usability":[{"format":"full_html","safe_value":"<p>In this release the user will be able to filter the time events in the graphs views. A time graph views is Gantt chart with links between tasks. Now the time graph views have a dialog box where the user can specify regexes to filter the time events in the view.<\/p>\n<p>It is now also possible to enable\/disable XML analysis from the tracing preference pages.<\/p>\n","value":"<p>In this release the user will be able to filter the time events in the graphs views. A time graph views is Gantt chart with links between tasks. Now the time graph views have a dialog box where the user can specify regexes to filter the time events in the view.<\/p>\r\n\r\n<p>It is now also possible to enable\/disable XML analysis from the tracing preference pages.<\/p>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 3.2.0\/Oxygen.2 update release. <\/p>\n<p>There are no architectural changes for the core framework.<\/p>\n<p>The data-driven analysis internal design has been rewritten to separate compilation unit and execution. This allows for better validation of the XML analysis.<\/p>\n<p>More support for the provisional Data Provider APIs have been provided for both XY views and Time Graph views to decouple UI and  Core components. Several views have been updated to this new APIs. The support in other views will be gradually added. The APIs will be made public once all views are migrated.<\/p>\n<p> <\/p>\n","value":"<p>The release is a small increment of our previous 3.2.0\/Oxygen.2 update release.&nbsp;<\/p>\r\n\r\n<p>There are no architectural changes for the core framework.<\/p>\r\n\r\n<p>The data-driven analysis internal design has been rewritten to separate compilation unit and execution. This allows for better validation of the XML analysis.<\/p>\r\n\r\n<p>More support for the provisional Data Provider APIs have been provided for both XY views and Time Graph views to decouple UI and&nbsp; Core components. Several views have been updated to this new APIs. The support in other views will be gradually added. The APIs will be made public once all views are migrated.<\/p>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>9 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul><p> <\/p>\n","value":"<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">9 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>A few APIs have been deprecated. New APIs have been added for later replacement. They will be removed in the 4.0 release for Photon.<\/p>\n","value":"<p>A few APIs have been deprecated. New APIs have been added for later replacement. They will be removed in the 4.0 release for Photon.<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2018-03-21 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 3.3.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\n<ul><li>Make the state system explorer a timegraph view<\/li>\n<li>Export views to image<\/li>\n<li>Dynamic filtering in the Control Flow View<\/li>\n<li>Event matching analysis<\/li>\n<li>Copy trace or link trace<\/li>\n<li>Status Bar support for XY views<\/li>\n<li>Pin and clone for XY charts<\/li>\n<li>Column comparators in the Call Stack View<\/li>\n<\/ul>","value":"<p>Trace Compass 3.3.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\r\n\r\n<ul>\r\n\t<li>Make the state system explorer a timegraph view<\/li>\r\n\t<li>Export views to image<\/li>\r\n\t<li>Dynamic filtering in the Control Flow View<\/li>\r\n\t<li>Event matching analysis<\/li>\r\n\t<li>Copy trace or link trace<\/li>\r\n\t<li>Status Bar support for XY views<\/li>\r\n\t<li>Pin and clone for XY charts<\/li>\r\n\t<li>Column comparators in the Call Stack View<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 3.3.0 is a minor release that ships with the Oxygen.3 update release.<\/p>\n<p>This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen.3<\/a>.<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n<div class=\"field-items\">\r\n<div class=\"field-item even\">\r\n<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n<div class=\"field-items\">\r\n<div class=\"field-item even\">\r\n<p><span style=\"color:rgb(51, 51, 51); font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">Trace Compass 3.3.0 is a minor release that ships with the Oxygen.3 <\/span><span style=\"color:rgb(51, 51, 51); font-family:open sans,helvetica neue,helvetica,arial,sans-serif; font-size:14px\">update release.<\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen.3<\/a>.<\/span><\/span><\/p>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed in the 4.0 release for Photon.<\/p>\n","value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\r\n\r\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed in the 4.0 release for Photon.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn33"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2018-03-07 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"3.3.0"}],"state":[{"value":"success"}],"title":"3.3.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/3.3.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n\r\n<ul>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\r\n\t<ul>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t\t<li>\r\n\t\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n\r\n<p><span style=\"font-size:14px\"><span style=\"font-family:arial,helvetica,sans-serif\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"3.3.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/3.3.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 3.1.0\/Oxygen.1 update release. <\/p>\n<p>There are no architectural changes for the core framework.<\/p>\n<p>It is now possible to add tracing nature to any Eclipse Project. The project explorer will show a Trace Compass folder underneath the configured project.<\/p>\n","value":"<p>The release is a small increment of our previous 3.1.0\/Oxygen.1 update release.&nbsp;<\/p>\r\n<p>There are no architectural changes for the core framework.<\/p>\r\n<p>It is now possible to add tracing nature to any Eclipse Project. The project explorer will show a Trace Compass folder underneath the configured project.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>9 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Trace Compass has been presented the trace visualization at Linux Plumbers Conference 13-15 September 2017. See below the link below for further information:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.linuxplumbersconf.org\/2017\/ocw\/proposals\/4780\">Trace Visualization: Analyse perf, bpf, kernel and userspace traces with Trace Compass<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Trace Compass was part of the following talk at LISA17 | USENIX Conference, October 29 - November 3 2017.<\/p>\n<ul><li>\n<p><a href=\"https:\/\/www.youtube.com\/watch?v=ihauGhgWZgQ\">Visual Tooling for Advanced Systems Analysis<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul><p> <\/p>\n","value":"<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">9 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial, helvetica, sans-serif;\">Trace Compass has been presented the trace visualization at Linux Plumbers Conference 13-15 September 2017. See below the link below for further information:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.linuxplumbersconf.org\/2017\/ocw\/proposals\/4780\">Trace Visualization: Analyse perf, bpf, kernel and userspace traces with Trace Compass<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass was part of the following talk at LISA17 | USENIX Conference, October 29 - November 3 2017.<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/www.youtube.com\/watch?v=ihauGhgWZgQ\">Visual Tooling for Advanced Systems Analysis<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>A few APIs have been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<br \/>\n\t <\/p>\n","value":"<p>A few APIs have been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<br \/>\r\n\t&nbsp;<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-12-20 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 3.2.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\n<ul><li>\n\t\tPin and clone timegraphs<\/li>\n<li>\n\t\tChart viewers<\/li>\n<li>\n\t\tConfiguring a project as tracing project<\/li>\n<li>\n\t\tVirtual Machine Analysis is deprecated<\/li>\n<li>\n\t\tStyle picking legends<\/li>\n<li>\n\t\tAdd preference to confirm before deleting supplementary files<\/li>\n<li>\n\t\tGeneralize critical path analysis<\/li>\n<li>\n\t\tAdd icons to views and analyses<\/li>\n<li>\n\t\tAdd a menu to install incubator features<\/li>\n<li>\n\t\tSupport script state value type for XML Analysis<\/li>\n<\/ul>","value":"<p>Trace Compass 3.2.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tPin and clone timegraphs<\/li>\r\n\t<li>\r\n\t\tChart viewers<\/li>\r\n\t<li>\r\n\t\tConfiguring a project as tracing project<\/li>\r\n\t<li>\r\n\t\tVirtual Machine Analysis is deprecated<\/li>\r\n\t<li>\r\n\t\tStyle picking legends<\/li>\r\n\t<li>\r\n\t\tAdd preference to confirm before deleting supplementary files<\/li>\r\n\t<li>\r\n\t\tGeneralize critical path analysis<\/li>\r\n\t<li>\r\n\t\tAdd icons to views and analyses<\/li>\r\n\t<li>\r\n\t\tAdd a menu to install incubator features<\/li>\r\n\t<li>\r\n\t\tSupport script state value type for XML Analysis<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 3.2.0 is a minor release that ships with the Oxygen.2 update release<\/p>\n<p>This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen.2<\/a>.<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t<div class=\"field-items\">\r\n\t\t<div class=\"field-item even\">\r\n\t\t\t<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t\t\t\t<div class=\"field-items\">\r\n\t\t\t\t\t<div class=\"field-item even\">\r\n\t\t\t\t\t\t<p><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">Trace Compass 3.2.0 is a minor release that ships with the Oxygen.2 <\/span><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">update release<\/span><\/p>\r\n\t\t\t\t\t<\/div>\r\n\t\t\t\t<\/div>\r\n\t\t\t<\/div>\r\n\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen.2<\/a>.<\/span><\/span><\/p>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<\/p>\n","value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\r\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn32"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2017-12-06 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"3.2.0"}],"state":[{"value":"success"}],"title":"3.2.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/3.2.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"3.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/3.2.0","usability":[]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 3.0.0\/Oxygen release. <\/p>\n<p>There are no architectural changes for the core framework.<\/p>\n<p>The data model and view implementation of XY charts have been decoupled to improve maintainability, testability and extendability. New APIs have been provided for that.<\/p>\n","value":"<p>The release is a small increment of our previous 3.0.0\/Oxygen release.&nbsp;<\/p>\r\n<p>There are no architectural changes for the core framework.<\/p>\r\n<p>The data model and view implementation of XY charts have been decoupled to improve maintainability, testability and extendability. New APIs have been provided for that.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>9 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph. <\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">9 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass can be setup using Oomph. <\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass is part of the Eclipse C\/C++ EPP. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>A few APIs have been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<\/p>\n","value":"<p>A few APIs have been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-09-27 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 3.1.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\n<ul><li>\n\t\tTime-based trace selection for experiments<\/li>\n<li>\n\t\tTime-based trace import<\/li>\n<li>\n\t\tMultiple symbol mapper support<\/li>\n<li>\n\t\tLinux Performance Counter Columns<\/li>\n<li>\n\t\tLinux Performance Counter Visualization<\/li>\n<li>\n\t\tPersist Expanded\/Collapsed State Of Timegraph Entries<\/li>\n<li>\n\t\tState System performance improvements<\/li>\n<li>\n\t\tVirtual Time Graph Views<br \/>\n\t\t <\/li>\n<\/ul><p> <\/p>\n","value":"<p>Trace Compass 3.1.0 focuses on new features and bug fixes. New APIs have been added as well. New features include:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tTime-based trace selection for experiments<\/li>\r\n\t<li>\r\n\t\tTime-based trace import<\/li>\r\n\t<li>\r\n\t\tMultiple symbol mapper support<\/li>\r\n\t<li>\r\n\t\tLinux Performance Counter Columns<\/li>\r\n\t<li>\r\n\t\tLinux Performance Counter Visualization<\/li>\r\n\t<li>\r\n\t\tPersist Expanded\/Collapsed State Of Timegraph Entries<\/li>\r\n\t<li>\r\n\t\tState System performance improvements<\/li>\r\n\t<li>\r\n\t\tVirtual Time Graph Views<br \/>\r\n\t\t&nbsp;<\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 3.1.0 is a minor release that ships with the Oxygen.1 update release<\/p>\n<p>This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen.1<\/a>.<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t<div class=\"field-items\">\r\n\t\t<div class=\"field-item even\">\r\n\t\t\t<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t\t\t\t<div class=\"field-items\">\r\n\t\t\t\t\t<div class=\"field-item even\">\r\n\t\t\t\t\t\t<p><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">Trace Compass 3.1.0 is a minor release that ships with the Oxygen.1 <\/span><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">update release<\/span><\/p>\r\n\t\t\t\t\t<\/div>\r\n\t\t\t\t<\/div>\r\n\t\t\t<\/div>\r\n\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen.1<\/a>.<\/span><\/span><\/p>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<\/p>\n","value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\r\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 4.0 release for Photon.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn31"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2017-09-20 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"3.1.0"}],"state":[{"value":"success"}],"title":"3.1.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/3.1.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n<p> <\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n<p>&nbsp;<\/p>\r\n"}],"subprojects":[],"themes":[],"title":"3.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/3.1.0","usability":[{"format":"full_html","safe_value":"<p>No changes regarding usability in this release.<\/p>\n","value":"<p>No changes regarding usability in this release.<\/p>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>There are no architectural changes in Trace Compass 3.0.0.<\/p>\n","value":"<p>There are no architectural changes in Trace Compass 3.0.0.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>8 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Many interactions with the CDT project. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">8 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Many interactions with the CDT project. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>The Trace Compass 3.0.0 major release removes APIs that had been deprecated for are at least 1 release cycle. Tools extending Trace Compass need to align with the updated and removed APIs when upgrading to Trace Compass 3.0.0.<\/p>\n<p>This release is part of the <a href=\"https:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen<\/a> Eclipse simultaneous release.<\/p>\n<p> <\/p>\n","value":"<p>The Trace Compass 3.0.0 major release removes APIs that had been deprecated for are at least 1 release cycle. Tools extending Trace Compass need to align with the updated and removed APIs when upgrading to Trace Compass 3.0.0.<\/p>\r\n<p>This release is part of the <a href=\"https:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen<\/a> Eclipse simultaneous release.<\/p>\r\n<p>&nbsp;<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-06-28 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 3.0.0 focuses on new features, bug fixes, API clean-ups. Some of the new features are:<\/p>\n<ul><li>\n\t\tConfigurable Marker Sets<\/li>\n<li>\n\t\tDisplay Trace Range in Project Explorer<\/li>\n<li>\n\t\tEnable\/Disable Trace Types<\/li>\n<li>\n\t\tAggregating threads in the Flame Graph<\/li>\n<li>\n\t\tLatency analysis for IRQ handlers<\/li>\n<li>\n\t\tDescriptive Statistics of Function Calls<\/li>\n<li>\n\t\tControl Flow View Thickness<\/li>\n<li>\n\t\tOpen Selected Traces As Experiment<\/li>\n<li>\n\t\tShow Analyses From Traces Under Experiments<\/li>\n<li>\n\t\tSegment Store on Disk<\/li>\n<li>\n\t\tExtensible XML schema<\/li>\n<\/ul><p> <\/p>\n","value":"<p>Trace Compass 3.0.0 focuses on new features, bug fixes, API clean-ups. Some of the new features are:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tConfigurable Marker Sets<\/li>\r\n\t<li>\r\n\t\tDisplay Trace Range in Project Explorer<\/li>\r\n\t<li>\r\n\t\tEnable\/Disable Trace Types<\/li>\r\n\t<li>\r\n\t\tAggregating threads in the Flame Graph<\/li>\r\n\t<li>\r\n\t\tLatency analysis for IRQ handlers<\/li>\r\n\t<li>\r\n\t\tDescriptive Statistics of Function Calls<\/li>\r\n\t<li>\r\n\t\tControl Flow View Thickness<\/li>\r\n\t<li>\r\n\t\tOpen Selected Traces As Experiment<\/li>\r\n\t<li>\r\n\t\tShow Analyses From Traces Under Experiments<\/li>\r\n\t<li>\r\n\t\tSegment Store on Disk<\/li>\r\n\t<li>\r\n\t\tExtensible XML schema<\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 3.0 is a major release with API breakage, new features, and bugfixes. <\/p>\n<p>This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen<\/a>.<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t<div class=\"field-items\">\r\n\t\t<div class=\"field-item even\">\r\n\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family:arial,helvetica,sans-serif;\">Trace Compass 3.0 is a major release with API breakage, new features, and bugfixes. <\/span><\/span><\/p>\r\n\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">This release will be part of <a href=\"http:\/\/projects.eclipse.org\/releases\/oxygen\">Oxygen<\/a>.<\/span><\/span><\/p>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>No end-of-life components.<\/p>\n","value":"<p>No end-of-life components.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[{"tid":"290"}],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/span><\/span><\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn30"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2017-06-07 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"3.0.0"}],"state":[{"value":"success"}],"title":"3.0.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/3.0.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"3.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/3.0.0","usability":[{"format":"full_html","safe_value":"<p>In this release the user experience of  experiments have been improved. Experiments are set of traces where all events are ordered in chronologial order. Now, the project explorer shows all available analysis and views under the experiment that provided by each trace.<\/p>\n<p>It is now also possible to open selected traces or trace folders directly as experiment using a newly added menu item.<\/p>\n<p>The scalability of the tool has been enhanced. Until now, Segment Stores were backed by in memory data structures, limiting their size. Now, they can be also implemented in a similar way to the State History Tree, with an external memory tree data structure. This enables Segment Stores to store far more data and some efficient operations such as lazy iteration and lazy sorting. These new data structures are used by the System Call Analysis and the Scatter Graph Viewer.<\/p>\n","value":"<p>In this release the user experience of&nbsp; experiments have been improved. Experiments are set of traces where all events are ordered in chronologial order. Now, the project explorer shows all available analysis and views under the experiment that provided by each trace.<\/p>\r\n<p>It is now also possible to open selected traces or trace folders directly as experiment using a newly added menu item.<\/p>\r\n<p>The scalability of the tool has been enhanced. Until now, Segment Stores were backed by in memory data structures, limiting their size. Now, they can be also implemented in a similar way to the State History Tree, with an external memory tree data structure. This enables Segment Stores to store far more data and some efficient operations such as lazy iteration and lazy sorting. These new data structures are used by the System Call Analysis and the Scatter Graph Viewer.<\/p>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 2.2.0\/Neon.2 release.  There are no architectural changes.<\/p>\n","value":"<p>The release is a small increment of our previous 2.2.0\/Neon.2 release.&nbsp; There are no architectural changes.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>8 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Many interactions with the CDT project. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">8 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Many interactions with the CDT project. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>A few API have been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\n<p>This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon.3<\/a>.<\/p>\n","value":"<p>A few API have been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\r\n<p>This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon.3<\/a>.<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2017-03-23 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 2.3.0 focuses on new features, bug fixes, source clean-up and preparation for 3.0 major release in Oxygen. Some of the new features are:<\/p>\n<ul><li>\n\t\tFutex Contention Latency Analysis<\/li>\n<li>\n\t\tPerspective Switcher<\/li>\n<li>\n\t\tSupport of trace aspects in XML analysis<\/li>\n<\/ul><p> <\/p>\n","value":"<p>Trace Compass 2.3.0 focuses on new features, bug fixes, source clean-up and preparation for 3.0 major release in Oxygen. Some of the new features are:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tFutex Contention Latency Analysis<\/li>\r\n\t<li>\r\n\t\tPerspective Switcher<\/li>\r\n\t<li>\r\n\t\tSupport of trace aspects in XML analysis<\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 2.3.0 is a minor release that ships with the Neon.3 update release<\/p>\n<p> <\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t<div class=\"field-items\">\r\n\t\t<div class=\"field-item even\">\r\n\t\t\t<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t\t\t\t<div class=\"field-items\">\r\n\t\t\t\t\t<div class=\"field-item even\">\r\n\t\t\t\t\t\t<p><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">Trace Compass 2.3.0 is a minor release that ships with the Neon.3 <\/span><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">update release<\/span><\/p>\r\n\t\t\t\t\t<\/div>\r\n\t\t\t\t<\/div>\r\n\t\t\t<\/div>\r\n\t\t\t<p>&nbsp;<\/p>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"filtered_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>","value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\r\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn23"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2017-03-01 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"2.3.0"}],"state":[{"value":"success"}],"title":"2.3.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/2.3.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF) - v1.8.2<\/a><\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"2.3.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/2.3.0","usability":[{"format":"full_html","safe_value":"<p>No changes regarding usability in this release.<\/p>\n","value":"<p>No changes regarding usability in this release.<\/p>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 2.1.0\/Neon.1 release.  There are no architectural changes.<\/p>\n","value":"<p>The release is a small increment of our previous 2.1.0\/Neon.1 release.&nbsp; There are no architectural changes.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>8 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys<\/a> solutions<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Many interactions with the CDT project. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Project members attended the Embedded Linux Conference Europe and presented at the co-located Tracing Summit:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/tracingsummit.org\/w\/images\/d\/d0\/Tracingsummit-2016-matthew-khouzam.pdf\">Advanced Trouble-Shooting of Critical Real-Time Systems<\/a><\/p>\n<\/li>\n<li>\n<p><a href=\"http:\/\/tracingsummit.org\/w\/images\/8\/8b\/TracingSummit2016_JUL.pdf\">Tracing and Modeling High-Level Multi-Threaded GUI Applications<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>Project members attended and presented at the <a href=\"http:\/\/www.embeddedconference.se\/\">Embedded Conference Scandinavia<\/a><\/p>\n<\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">8 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Bugzilla has been used for planning and bug tracking<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys<\/a> solutions<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Many interactions with the CDT project. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\">Project members attended the Embedded Linux Conference Europe and presented at the co-located Tracing Summit:<\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><a href=\"http:\/\/tracingsummit.org\/w\/images\/d\/d0\/Tracingsummit-2016-matthew-khouzam.pdf\">Advanced Trouble-Shooting of Critical Real-Time Systems<\/a><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><a href=\"http:\/\/tracingsummit.org\/w\/images\/8\/8b\/TracingSummit2016_JUL.pdf\"><span class=\"mw-headline\" id=\"Tracing_and_Modeling_High-Level_Multi-Threaded_GUI_Applications.2C_Genevi.C3.A8ve_Bastien_.28Ecole_Polytechnique_Montreal.29\">Tracing and Modeling High-Level Multi-Threaded GUI Applications<\/span><\/a><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span class=\"mw-headline\">Project members attended and presented at the <a href=\"http:\/\/www.embeddedconference.se\/\">Embedded Conference Scandinavia<\/a><\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>A few API have been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\n<p>This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon.2<\/a>.<\/p>\n","value":"<p>A few API have been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\r\n<p>This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon.2<\/a>.<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-12-21 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 2.2.0 focuses on new features and bug fixes. Some of the new features are:<\/p>\n<ul><li>\n\t\tKernel analysis\n<ul><li>\n\t\t\t\tSpeed and storage improvements<\/li>\n<\/ul><\/li>\n<li>\n\t\tLTTng Analysis Machine Interface (LAMI)\n<ul><li>\n\t\t\t\tSupport LAMI 1.0 features (MI version, compatibility test)<\/li>\n<li>\n\t\t\t\tImproved chart axis format<\/li>\n<\/ul><\/li>\n<li>\n\t\tCustom parsers\n<ul><li>\n\t\t\t\tSupport for per-event extra fields<\/li>\n<\/ul><\/li>\n<li>\n\t\tTrace import\n<ul><li>\n\t\t\t\tSupport new archive formats and handle pax headers<\/li>\n<\/ul><\/li>\n<li>\n\t\tSegment store\n<ul><li>\n\t\t\t\tLazy segment store loading<\/li>\n<li>\n\t\t\t\tImproved merged statistics<\/li>\n<li>\n\t\t\t\tSupport export to TSV of tables and statistics<\/li>\n<\/ul><\/li>\n<li>\n\t\tTrace synchronization\n<ul><li>\n\t\t\t\tSupport for automatic sync of traces from same host<\/li>\n<\/ul><\/li>\n<li>\n\t\tUser interface\n<ul><li>\n\t\t\t\tAdded icons for built-in analyses and views<\/li>\n<li>\n\t\t\t\tDouble-click to zoom in Flame Graph view<\/li>\n<li>\n\t\t\t\tImproved marker label visibility<\/li>\n<\/ul><\/li>\n<li>\n\t\tUser guide and developer guide updates<\/li>\n<\/ul>","value":"<p>Trace Compass 2.2.0 focuses on new features and bug fixes. Some of the new features are:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tKernel analysis\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSpeed and storage improvements<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tLTTng Analysis Machine Interface (LAMI)\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport LAMI 1.0 features (MI version, compatibility test)<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tImproved chart axis format<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tCustom parsers\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for per-event extra fields<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tTrace import\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport new archive formats and handle pax headers<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tSegment store\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tLazy segment store loading<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tImproved merged statistics<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSupport export to TSV of tables and statistics<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tTrace synchronization\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for automatic sync of traces from same host<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tUser interface\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tAdded icons for built-in analyses and views<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tDouble-click to zoom in Flame Graph view<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tImproved marker label visibility<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tUser guide and developer guide updates<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 2.2 is a minor release that ships with the Neon.2 update release<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t<div class=\"field-items\">\r\n\t\t<div class=\"field-item even\">\r\n\t\t\t<p><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">Trace Compass 2.2 is a minor release that ships with the Neon.2 <\/span><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">update release<\/span><\/p>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n<p>\tA few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\n","value":"<p>We have no end-of-life issues to discuss at this time.<br \/>\r\n\t<br \/>\r\n\tA few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn22"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2016-12-07 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"2.2.0"}],"state":[{"value":"success"}],"title":"2.2.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/2.2.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p>There are no security issues.<\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a><\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"2.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/2.2.0","usability":[{"format":"full_html","safe_value":"<p>A number of new features of this release aim to improve usability:<\/p>\n<ul><li>\n\t\tDouble-click to zoom in Flame Graph view<\/li>\n<li>\n\t\tAdded icons for analyses and views<\/li>\n<\/ul>","value":"<p>A number of new features of this release aim to improve usability:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tDouble-click to zoom in Flame Graph view<\/li>\r\n\t<li>\r\n\t\tAdded icons for analyses and views<\/li>\r\n<\/ul>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>The release is a small increment of our previous 2.0.0\/Neon release.  There are no architectural changes.<\/p>\n","value":"<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">The release is a small increment of our previous 2.0.0\/Neon release. &nbsp;There are no architectural changes.<\/span><\/span><\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>8 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking.<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys<\/a> solutions<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Many interactions with the CDT project. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">8 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Bugzilla has been used for planning and bug tracking.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys<\/a> solutions<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Many interactions with the CDT project. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\n<p>This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon.1<\/a>.<\/p>\n","value":"<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/span><\/span><\/p>\r\n<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon.1<\/a>.<\/span><\/span><\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-09-28 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 2.1.0 focuses on new features and bug fixes. Some of the new features are:<\/p>\n<ul><li>\n\t\tOperating system overview<\/li>\n<li>\n\t\tCall graph analysis\n<ul><li>\n\t\t\t\tFlame graph view<\/li>\n<li>\n\t\t\t\tFunction duration density view<\/li>\n<\/ul><\/li>\n<li>\n\t\tLTTng Control view enhancements\n<ul><li>\n\t\t\t\tEnabling all kernel tracepoints and syscall at once<\/li>\n<li>\n\t\t\t\tEnabling LTTng Kernel events by name<\/li>\n<li>\n\t\t\t\tEnabling specific LTTng Kernel syscall events<\/li>\n<li>\n\t\t\t\tSupport for tracing Java and Python applications<\/li>\n<\/ul><\/li>\n<li>\n\t\t    4 Control Flow view enhancements\n<ul><li>\n\t\t\t\tFollowing events per TID<\/li>\n<li>\n\t\t\t\tOptimizing threads grouping<\/li>\n<\/ul><\/li>\n<li>\n\t\t    5 Custom Text\/XML parser enhancements\n<ul><li>\n\t\t\t\tSupport for event types in custom parsers<\/li>\n<\/ul><\/li>\n<li>\n\t\t    6 Latency analysis enhancements\n<ul><li>\n\t\t\t\tTotal latency statistics<\/li>\n<\/ul><\/li>\n<li>\n\t\t    7 Other enhancements\n<ul><li>\n\t\t\t\tOpen XML Editor for data-driven analysis<\/li>\n<li>\n\t\t\t\tProgress bar for indexing of CTF traces<\/li>\n<li>\n\t\t\t\tMultiple instances of XML views of same type<\/li>\n<li>\n\t\t\t\tJava utility logging tracepoints for troubleshooting of Trace Compass<\/li>\n<\/ul><\/li>\n<\/ul>","value":"<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Trace Compass 2.1.0 focuses on new features and bug fixes. Some of the new features are:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Operating system overview<\/span><\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Call graph analysis<\/span><\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Flame graph view<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Function duration density view<\/span><\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">LTTng Control view enhancements<\/span><\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Enabling all kernel tracepoints and syscall at once<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Enabling LTTng Kernel events by name<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Enabling specific LTTng Kernel syscall events<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Support for tracing Java and Python applications<\/span><\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">&nbsp;&nbsp;&nbsp; 4 Control Flow view enhancements<\/span><\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Following events per TID<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Optimizing threads grouping<\/span><\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">&nbsp;&nbsp;&nbsp; 5 Custom Text\/XML parser enhancements<\/span><\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Support for event types in custom parsers<\/span><\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">&nbsp;&nbsp;&nbsp; 6 Latency analysis enhancements<\/span><\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Total latency statistics<\/span><\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">&nbsp;&nbsp;&nbsp; 7 Other enhancements<\/span><\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Open XML Editor for data-driven analysis<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Progress bar for indexing of CTF traces<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Multiple instances of XML views of same type<\/span><\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 14px;\">Java utility logging tracepoints for troubleshooting of Trace Compass<\/span><\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 2.1 is a minor release that ships with the Neon.1 update release.<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t<div class=\"field-items\">\r\n\t\t<div class=\"field-item even\">\r\n\t\t\t<p><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">Trace Compass 2.1 is a minor release that ships with the Neon.1&nbsp;<\/span><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">update release.<\/span><\/p>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n<p>A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">We have no end-of-life issues to discuss at this time.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">A few API has been deprecated. New APIs have been added for later replacement. They will be removed for the 3.0 release for Oxygen.<\/span><\/span><\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/span><\/span><\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn21"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2016-09-21 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"2.1.0"}],"state":[{"value":"success"}],"title":"2.1.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/2.1.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">There are no security issues.<\/span><\/span><\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a><\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions. It supports the MI versions 2.0 and 3.0.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"2.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/2.1.0","usability":[{"format":"full_html","safe_value":"<p>A number of new features of this release aim to improve usability:<\/p>\n<ul><li>\n\t\tOpen XML Editor for data-driven analysis<\/li>\n<li>\n\t\tProgress bar for indexing of CTF traces to give user feedback<\/li>\n<li>\n\t\tUse same mouse actions in XY graphs than in Time Graph views<\/li>\n<\/ul>","value":"<p><span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">A number of new features of this release aim to improve usability:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Open XML Editor for data-driven analysis<\/span><\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Progress bar for indexing of CTF traces to give user feedback<\/span><\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:14px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Use same mouse actions in XY graphs than in Time Graph views<\/span><\/span><\/li>\r\n<\/ul>\r\n"}]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-08-05 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"2.0.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/2.0.1","usability":[]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>Trace Compass has been providing extension points for adding new trace or log types and for adding trace analysis modules.<\/p>\n<p>In this release 2 new extension points have been added:<\/p>\n<ul><li>\n<p>org.eclipse.tracecompass.tmf.core.analysis.ondemand<br \/>\n\t\t\tThis extension point is used to provide on-demand analyses. Unlike regular analyses, the on-demand ones are only executed when the user specifies it.<\/p>\n<\/li>\n<li>\n<p>org.eclipse.tracecompass.tmf.ui.symbolProvider<br \/>\n\t\t\tThis extension point can be used to transform from symbol addresses that might be found inside a TmfTrace into human readable texts, for example function names (e.g. used for Call Stack views)<\/p>\n<\/li>\n<\/ul><p> <\/p>\n","value":"<p><span style=\"font-size: 12px;\">Trace Compass has been providing extension points for adding new trace or log types and for adding trace analysis modules.<\/span><\/p>\r\n<p><span style=\"font-size: 12px;\">In this release 2 new extension points have been added:<\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">org.eclipse.tracecompass.tmf.core.analysis.ondemand<br \/>\r\n\t\t\tThis extension point is used to provide on-demand analyses. Unlike regular analyses, the on-demand ones are only executed when the user specifies it.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">org.eclipse.tracecompass.tmf.ui.symbolProvider<br \/>\r\n\t\t\tThis extension point can be used to transform from symbol addresses that might be found inside a TmfTrace into human readable texts, for example function names (e.g. used for Call Stack views)<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n<p>8 active committers from 3 different organizations<\/p>\n<\/li>\n<li>\n<p>Trace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/p>\n<\/li>\n<li>\n<p>User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/p>\n<\/li>\n<li>\n<p>Bugzilla has been used for planning and bug tracking. In the future the project will also pilot the use of the open-source ALM (application lifecycle management) tool. This will help us to improve project planning and collaboration across various contributing organisations. An instance of Tuleap is currently installed at Eclipse and the project can be found <a href=\"https:\/\/tuleap.eclipse.org\/projects\/tracecompass\">here<\/a>.<\/p>\n<\/li>\n<li>\n<p>Centralized update site and download page for the standalone RCP<\/p>\n<\/li>\n<li>\n<p>Trace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys<\/a> solutions<\/p>\n<\/li>\n<li>\n<p>Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/p>\n<\/li>\n<li>\n<p>Many interactions with the CDT project. One committer is also committer in CDT.<\/p>\n<\/li>\n<li>\n<p>Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of  the reseach projects. See below for a link to the current active research track:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p>A project member presented at EclipseCon North America 2016 and participated at the co-located CDT summit:<\/p>\n<ul><li>\n<p><a href=\"https:\/\/www.eclipsecon.org\/na2016\/session\/real-time-system-troubleshooting-eclipse-trace-compass\">Real-Time System Troubleshooting with Eclipse Trace Compass<\/a><\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/CDT\/summitecon2016\">CDT\/Linux Tools\/PTP\/Trace Compass Summit at EclipseCon 2016<\/a><\/p>\n<\/li>\n<\/ul><\/li>\n<\/ul><p> <\/p>\n","value":"<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">8 active committers from 3 different organizations<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Trace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Bugzilla has been used for planning and bug tracking. In the future the project will also pilot the use of the open-source ALM (application lifecycle management) tool. This will help us to improve project planning and collaboration across various contributing organisations. An instance of Tuleap is currently installed at Eclipse and the project can be found <a href=\"https:\/\/tuleap.eclipse.org\/projects\/tracecompass\">here<\/a>.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Centralized update site and download page for the standalone RCP<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Trace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys<\/a> solutions<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth).<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Many interactions with the CDT project. One committer is also committer in CDT.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many new features and enhancements for Trace Compass have been a direct outcome of&nbsp; the reseach projects. See below for a link to the current active research track:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">A project member presented at EclipseCon North America 2016 and participated at the co-located CDT summit:<\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\"><a href=\"https:\/\/www.eclipsecon.org\/na2016\/session\/real-time-system-troubleshooting-eclipse-trace-compass\">Real-Time System Troubleshooting with Eclipse Trace Compass<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\"><a href=\"https:\/\/wiki.eclipse.org\/CDT\/summitecon2016\">CDT\/Linux Tools\/PTP\/Trace Compass Summit at EclipseCon 2016<\/a><\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>New API were added to Trace Compass 2.0 as well as API have been cleaned-up for this release.<\/p>\n<p>The feature \"LTTng Live trace reading\" has been disabled for Trace Compass 2.0. It was decided to disable the LTTng Live trace support because of the shortcomings documented in bug <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=486728\">486728<\/a>. We look forward to addressing the shortcomings in the future releases in order to re-enable the feature.<\/p>\n","value":"<p>New API were added to Trace Compass 2.0 as well as API have been cleaned-up for this release.<\/p>\r\n<p>The feature &quot;LTTng Live trace reading&quot; has been disabled for Trace Compass 2.0. It was decided to disable the LTTng Live trace support because of the shortcomings documented in bug <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=486728\">486728<\/a>. We look forward to addressing the shortcomings in the future releases in order to re-enable the feature.<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-06-22 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 2.0 focuses on new features, bug fixes, and API addition and cleanup.<\/p>\n<p>\tSome of the new features are:<\/p>\n<ul><li>\n\t\tAdded Extension points<br \/>\n\t\tIn this release 2 new extension points have been added:\n<ul><li>\n\t\t\t\torg.eclipse.tracecompass.tmf.core.analysis.ondemand<br \/>\n\t\t\t\tThis extension point is used to provide on-demand analyses. Unlike regular analyses, the on-demand ones are only executed when the user specifies it.<\/li>\n<li>\n\t\t\t\torg.eclipse.tracecompass.tmf.ui.symbolProvider<br \/>\n\t\t\t\tThis extension point can be used to transform from symbol addresses that might be found inside a TmfTrace into human readable texts, for example function names (e.g. used for Call Stack views)<\/li>\n<\/ul><\/li>\n<li>\n\t\tIntegration with LTTng-Analyses\n<ul><li>\n\t\t\t\tProject View additions<\/li>\n<li>\n\t\t\t\tRunning an analysis<\/li>\n<li>\n\t\t\t\tResult reports<\/li>\n<li>\n\t\t\t\tCreating custom charts<\/li>\n<li>\n\t\t\t\tImporting custom analyses<\/li>\n<\/ul><\/li>\n<li>\n\t\tCritical flow view<\/li>\n<li>\n\t\tData-driven pattern detection<br \/>\n\t\tThe data-driven analysis and view of Trace Compass has been augmented to support data-driven pattern analysis. With this it possible to define a pattern matching algorithm and populate Timing Analysis views. Other types of latency or timing analyses can be now defined using this approach.<\/li>\n<li>\n\t\tTime graph view improvements\n<ul><li>\n\t\t\t\tGridlines in time graph views<\/li>\n<li>\n\t\t\t\tGrid lines have been added to the time graph views such as the Control Flow view.<\/li>\n<li>\n\t\t\t\tPersist settings (e.g. filters) for open traces<\/li>\n<li>\n\t\t\t\tSupport for searching within time graph views (e.g. search for process in Control Flow view.<\/li>\n<li>\n\t\t\t\tSupport of vertical zooming in time graph views<\/li>\n<li>\n\t\t\t\tBookmarks and custom markers in time graph views<\/li>\n<li>\n\t\t\t\tHorizontal scrolling using Shift+MouseWheel<\/li>\n<\/ul><\/li>\n<li>\n\t\tSystem call latency analysis\n<ul><li>\n\t\t\t\tSystem call latency table<\/li>\n<li>\n\t\t\t\tSystem call latency scatter graph<\/li>\n<li>\n\t\t\t\tSystem call latency statistics<\/li>\n<li>\n\t\t\t\tSystem call latency density<\/li>\n<\/ul><\/li>\n<li>\n\t\tCritical flow view<br \/>\n\t\tA critical flow analysis and view has been added to show dependency chains for a given process.<\/li>\n<li>\n\t\tVirtual CPU view (analysis of virtual machines)<\/li>\n<li>\n\t\tBookmarks and custom markers\n<ul><li>\n\t\t\t\tSupport for user bookmarks in time graph views<\/li>\n<li>\n\t\t\t\tLost event markers in time graph views<\/li>\n<li>\n\t\t\t\tNavigation for trace markers in time graph Views<\/li>\n<li>\n\t\t\t\tAPI for trace specific markers<\/li>\n<\/ul><\/li>\n<li>\n\t\tResources view improvements\n<ul><li>\n\t\t\t\tDisplay of soft IRQ names in the Resources view<\/li>\n<li>\n\t\t\t\tExecution context and state aggregation<\/li>\n<li>\n\t\t\t\tFollowing a single CPU across views (per CPU filtering)<\/li>\n<\/ul><\/li>\n<li>\n\t\tControl Flow view Improvements\n<ul><li>\n\t\t\t\tSupport for sorting of process based on columns in the Control Flow view<\/li>\n<li>\n\t\t\t\tFollowing single thread across views (thread filtering)<\/li>\n<li>\n\t\t\t\tGrouping threads under a trace parent<\/li>\n<li>\n\t\t\t\tSelecting flat or hierarchical thread presentation<\/li>\n<\/ul><\/li>\n<li>\n\t\tCPU Usage view improvements\n<ul><li>\n\t\t\t\tPer CPU filtering in CPU Usage view<\/li>\n<\/ul><\/li>\n<li>\n\t\tKernel memory usage analysis and view<\/li>\n<li>\n\t\tLinux Input\/Output analysis and I\/O Activity view<\/li>\n<li>\n\t\tManage XML analysis files<\/li>\n<li>\n\t\tDisplay of analysis properties<\/li>\n<li>\n\t\tImporting traces as experiment<\/li>\n<li>\n\t\tImporting LTTng traces as experiment from Control view<\/li>\n<li>\n\t\tEvents Table filtering UI improvement<\/li>\n<li>\n\t\tSymbol provider for Call stack view<\/li>\n<li>\n\t\tPer CPU thread 0<\/li>\n<li>\n\t\tUpdated analysis requirement API\n<ul><li>\n\t\t\t\tAPI clean-up of analyis requirement API<\/li>\n<li>\n\t\t\t\tAdded API to support requirements on event types and event fields. Using event field requirements it possible to define analysis requirements on LTTng event contexts<\/li>\n<li>\n\t\t\t\tUpdated LTTng UST Call Stack and Kernel CPU Usage analysis requirement implementation<\/li>\n<\/ul><\/li>\n<li>\n\t\tPie charts in Statistics view<\/li>\n<li>\n\t\tSupport for LTTng 2.8+ Debug Info<\/li>\n<\/ul>","value":"<div>\r\n\tTrace Compass 2.0 focuses on new features, bug fixes, and API addition and cleanup.<\/div>\r\n<div>\r\n\tSome of the new features are:<\/div>\r\n<ul>\r\n\t<li>\r\n\t\tAdded Extension points<br \/>\r\n\t\tIn this release 2 new extension points have been added:\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\torg.eclipse.tracecompass.tmf.core.analysis.ondemand<br \/>\r\n\t\t\t\tThis extension point is used to provide on-demand analyses. Unlike regular analyses, the on-demand ones are only executed when the user specifies it.<\/li>\r\n\t\t\t<li>\r\n\t\t\t\torg.eclipse.tracecompass.tmf.ui.symbolProvider<br \/>\r\n\t\t\t\tThis extension point can be used to transform from symbol addresses that might be found inside a TmfTrace into human readable texts, for example function names (e.g. used for Call Stack views)<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tIntegration with LTTng-Analyses\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tProject View additions<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tRunning an analysis<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tResult reports<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tCreating custom charts<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tImporting custom analyses<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tCritical flow view<\/li>\r\n\t<li>\r\n\t\tData-driven pattern detection<br \/>\r\n\t\tThe data-driven analysis and view of Trace Compass has been augmented to support data-driven pattern analysis. With this it possible to define a pattern matching algorithm and populate Timing Analysis views. Other types of latency or timing analyses can be now defined using this approach.<\/li>\r\n\t<li>\r\n\t\tTime graph view improvements\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tGridlines in time graph views<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tGrid lines have been added to the time graph views such as the Control Flow view.<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tPersist settings (e.g. filters) for open traces<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for searching within time graph views (e.g. search for process in Control Flow view.<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSupport of vertical zooming in time graph views<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tBookmarks and custom markers in time graph views<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tHorizontal scrolling using Shift+MouseWheel<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tSystem call latency analysis\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSystem call latency table<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSystem call latency scatter graph<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSystem call latency statistics<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSystem call latency density<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tCritical flow view<br \/>\r\n\t\tA critical flow analysis and view has been added to show dependency chains for a given process.<\/li>\r\n\t<li>\r\n\t\tVirtual CPU view (analysis of virtual machines)<\/li>\r\n\t<li>\r\n\t\tBookmarks and custom markers\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for user bookmarks in time graph views<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tLost event markers in time graph views<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tNavigation for trace markers in time graph Views<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tAPI for trace specific markers<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tResources view improvements\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tDisplay of soft IRQ names in the Resources view<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tExecution context and state aggregation<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tFollowing a single CPU across views (per CPU filtering)<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tControl Flow view Improvements\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for sorting of process based on columns in the Control Flow view<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tFollowing single thread across views (thread filtering)<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tGrouping threads under a trace parent<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSelecting flat or hierarchical thread presentation<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tCPU Usage view improvements\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tPer CPU filtering in CPU Usage view<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tKernel memory usage analysis and view<\/li>\r\n\t<li>\r\n\t\tLinux Input\/Output analysis and I\/O Activity view<\/li>\r\n\t<li>\r\n\t\tManage XML analysis files<\/li>\r\n\t<li>\r\n\t\tDisplay of analysis properties<\/li>\r\n\t<li>\r\n\t\tImporting traces as experiment<\/li>\r\n\t<li>\r\n\t\tImporting LTTng traces as experiment from Control view<\/li>\r\n\t<li>\r\n\t\tEvents Table filtering UI improvement<\/li>\r\n\t<li>\r\n\t\tSymbol provider for Call stack view<\/li>\r\n\t<li>\r\n\t\tPer CPU thread 0<\/li>\r\n\t<li>\r\n\t\tUpdated analysis requirement API\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tAPI clean-up of analyis requirement API<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tAdded API to support requirements on event types and event fields. Using event field requirements it possible to define analysis requirements on LTTng event contexts<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tUpdated LTTng UST Call Stack and Kernel CPU Usage analysis requirement implementation<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tPie charts in Statistics view<\/li>\r\n\t<li>\r\n\t\tSupport for LTTng 2.8+ Debug Info<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\n<p>This release includes new features, API changes and additions to the framework as well as new extension points.<\/p>\n<p>This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon<\/a>.<\/p>\n<p> <\/p>\n","summary":"","value":"<div class=\"field field-name-body field-type-text-with-summary field-label-hidden\">\r\n\t<div class=\"field-items\">\r\n\t\t<div class=\"field-item even\">\r\n\t\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/span><\/span><\/p>\r\n\t\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">This release includes new features, API changes and additions to the framework as well as new extension points.<\/span><\/span><\/p>\r\n\t\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">This release is part of <a href=\"https:\/\/projects.eclipse.org\/releases\/neon\">Neon<\/a>.<\/span><\/span><\/p>\r\n\t\t<\/div>\r\n\t<\/div>\r\n<\/div>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>New API were added to Trace Compass 2.0 as well as API have been cleaned-up for this release.<\/p>\n<p>The feature \"LTTng Live trace reading\" has been disabled for Trace Compass 2.0.It was decided to disable the LTTng Live trace support because of the shortcomings documented in bug <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=486728\">486728<\/a>.  We look forward to addressing the shortcomings in the future releases in order to re-enable the feature.<\/p>\n<p> <\/p>\n","value":"<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">New API were added to Trace Compass 2.0 as well as API have been cleaned-up for this release.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The feature &quot;LTTng Live trace reading&quot; has been disabled for Trace Compass 2.0.It was decided to disable the LTTng Live trace support because of the shortcomings documented in bug <a href=\"https:\/\/bugs.eclipse.org\/bugs\/show_bug.cgi?id=486728\">486728<\/a>.&nbsp; We look forward to addressing the shortcomings in the future releases in order to re-enable the feature.<\/span><\/span><\/p>\r\n<p>&nbsp;<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n<p> <\/p>\n","value":"<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/span><\/span><\/p>\r\n<p>&nbsp;<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn20"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2016-06-15 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"2.0.0"}],"state":[{"value":"success"}],"title":"2.0.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/2.0.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">There are no security issues.<\/span><\/span><\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n<p><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a><\/p>\n<ul><li>\n<p>Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/p>\n<\/li>\n<li>\n<p>Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/p>\n<\/li>\n<li>\n<p>Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/p>\n<\/li>\n<\/ul><\/li>\n<li>\n<p><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/p>\n<\/li>\n<li>\n<p><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/p>\n<\/li>\n<li>\n<p>The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/p>\n<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\n<p>For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/p>\n","value":"<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a><\/span><\/span><\/p>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/span><\/p>\r\n\t\t\t<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">For the integration of the command-line analysis Trace Compass is able to consume analysis results specified by the <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">LTTng Analysis Machine Interface<\/a>.<\/span><\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"2.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/2.0.0","usability":[{"format":"full_html","safe_value":"<p>User experience is very important for us and we continuously work on improving the user experience.<\/p>\n<ul><li>\n<p>The UI components support for keyboard navigation.<\/p>\n<\/li>\n<li>\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\n<li>\n<p>Stream-lined key handling across Time Graph views<\/p>\n<\/li>\n<li>\n<p>Trace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/p>\n<\/li>\n<\/ul><p>Trace Compass 2.0 provides more capabilities for the user to perform custom trace analysis without writing any Java code and extending Trace Compass.<\/p>\n<p>First of all, the existing data-driven analysis for Trace Compass has been enhanced for pattern detection using finite state machines (FSM). Defining such a data-driven pattern matching it is possible to perform latency and timing analysis of  real-time applications or systems. Several latency analysis views have been added that can be populated using the data-driven pattern detection. Users now can define custom patterns, load them into Trace Compass and analyse the timing of their system. No Java code is required for that. For more information about that see the Trace Compass user guide.<\/p>\n<p>Secondly, it is now possible to run external analysis scripts (e.g. written in Python, Perl) and programs on the trace data. Users often write scripts to perform custom analysis. Scripts can easily be integrated into continuous integration. With this release Trace Compass provides a way to integrate command-line scripts or programs with the rich set of UI features of Trace Compass. Scripts can now be executed from Trace Compass and the output will be loaded as reports into Trace Compass. Such reports will point users to problem  areas in the trace data. The reports can be visualized as tables, histograms and scatter charts. From the report it is possible to navigate to the trace location and use the existing views to analyze the trace data further. and to find root causes of the problem areas.<br \/>\n\tA <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">machine interface<\/a> has been defined that allows for this integration. <a href=\"https:\/\/github.com\/lttng\/lttng-analyses\">LTTng Analysis<\/a> scripts for LTTng kernel traces have been updated to comply with the machine interface and are integrated with Trace Compass. Users can also provide user-defined scripts for any trace type in order to create custom reports.<\/p>\n","value":"<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">User experience is very important for us and we continuously work on improving the user experience.<\/span><\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">The UI components support for keyboard navigation.<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">All of our strings are externalized but there are currently no language packs.<\/span><\/span><\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\">Stream-lined key handling across Time Graph views<\/span><\/span><\/p>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<p><span style=\"font-family:arial,helvetica,sans-serif;\"><span style=\"font-size: 12px;\"><span style=\"font-size: 12px;\">Trace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/span><\/span><\/span><\/p>\r\n\t<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Trace Compass 2.0 provides more capabilities for the user to perform custom trace analysis without writing any Java code and extending Trace Compass.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">First of all, the existing data-driven analysis for Trace Compass has been enhanced for pattern detection using finite state machines (FSM). Defining such a data-driven pattern matching it is possible to perform latency and timing analysis of&nbsp; real-time applications or systems. Several latency analysis views have been added that can be populated using the data-driven pattern detection. Users now can define custom patterns, load them into Trace Compass and analyse the timing of their system. No Java code is required for that. For more information about that see the Trace Compass user guide.<\/span><\/span><\/p>\r\n<p><span style=\"font-size:12px;\"><span style=\"font-family: arial,helvetica,sans-serif;\">Secondly, it is now possible to run external analysis scripts (e.g. written in Python, Perl) and programs on the trace data. Users often write scripts to perform custom analysis. Scripts can easily be integrated into continuous integration. With this release Trace Compass provides a way to integrate command-line scripts or programs with the rich set of UI features of Trace Compass. Scripts can now be executed from Trace Compass and the output will be loaded as reports into Trace Compass. Such reports will point users to problem&nbsp; areas in the trace data. The reports can be visualized as tables, histograms and scatter charts. From the report it is possible to navigate to the trace location and use the existing views to analyze the trace data further. and to find root causes of the problem areas.<br \/>\r\n\tA <a href=\"https:\/\/github.com\/lttng\/lami-spec\/blob\/master\/lami.md\">machine interface<\/a> has been defined that allows for this integration. <a href=\"https:\/\/github.com\/lttng\/lttng-analyses\">LTTng Analysis<\/a> scripts for LTTng kernel traces have been updated to comply with the machine interface and are integrated with Trace Compass. Users can also provide user-defined scripts for any trace type in order to create custom reports.<\/span><\/span><\/p>\r\n"}]},{"apis":[{"value":"0"}],"architecture":[],"communities":[],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-03-25 00:00:00"}],"deliverables":[],"description":[],"endoflife":[],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[],"noteworthy":[],"parent_project":[{"id":"tools.tracecompass"}],"review":{"state":[{}]},"screenshots":[],"security":[],"standards":[],"subprojects":[],"themes":[],"title":"1.2.1","type":[{"value":"3"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/1.2.1","usability":[]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>No architectural changes for this release.<\/p>\n","value":"<p>No architectural changes for this release.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n\t\t7 active committers from 3 different organizations<\/li>\n<li>\n\t\tTrace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/li>\n<li>\n\t\tUser interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/li>\n<li>\n\t\tBugzilla has been used for planning and bug tracking. In the future the project will also pilot the use of the open-source ALM (application lifecycle management) tool. This will help us to improve project planning and collaboration across various contributing organisations. An instance of Tuleap is currently installed at Eclipse and the project can be found <a href=\"https:\/\/tuleap.eclipse.org\/projects\/tracecompass\">here<\/a>.<\/li>\n<li>\n\t\tCentralized update site and download page for the standalone RCP<\/li>\n<li>\n\t\tTrace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/li>\n<li>\n\t\tStrong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/li>\n<li>\n\t\tMany interactions with the CDT project. One committer is also committer in CDT.<\/li>\n<li>\n\t\tTrace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many enhancements for Trace Compass has been an outcome of these reseach projects. See below for a link to the current active research track:\n<ul><li>\n\t\t\t\t<a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">7 active committers from 3 different organizations<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Trace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">User interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Bugzilla has been used for planning and bug tracking. In the future the project will also pilot the use of the open-source ALM (application lifecycle management) tool. This will help us to improve project planning and collaboration across various contributing organisations. An instance of Tuleap is currently installed at Eclipse and the project can be found <a href=\"https:\/\/tuleap.eclipse.org\/projects\/tracecompass\">here<\/a>.<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Centralized update site and download page for the standalone RCP<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Trace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Strong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Many interactions with the CDT project. One committer is also committer in CDT.<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Trace Compass has been the preferred Trace Analysis Tool for students as part of the trace research projects with the Polytechnique Montreal university. Many enhancements for Trace Compass has been an outcome of these reseach projects. See below for a link to the current active research track:<\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-size:12px;\"><a href=\"https:\/\/hsdm.dorsal.polymtl.ca\/\">Software Debugging and Monitoring for Heterogeneous Many-Core Telecom Systems<\/a><\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2016-02-26 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 1.2 focuses on bug fixes and new features such as:<\/p>\n<ul><li>\n\t\tLTTng Control view enhancements\n<ul><li>\n\t\t\t\tSupport for LTTng session profiles (save, load and manage profiles)<\/li>\n<li>\n\t\t\t\tSupport for filtering of kernel events<\/li>\n<\/ul><\/li>\n<li>\n\t\tSupport for filtering in Resources view<\/li>\n<li>\n\t\tPersistent filter in Control Flow and Resources view<\/li>\n<li>\n\t\tSupport for refreshing of local traces<\/li>\n<li>\n\t\tTrace indexing improvement<\/li>\n<\/ul>","value":"<p>Trace Compass 1.2 focuses on bug fixes and new features such as:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tLTTng Control view enhancements\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for LTTng session profiles (save, load and manage profiles)<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for filtering of kernel events<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tSupport for filtering in Resources view<\/li>\r\n\t<li>\r\n\t\tPersistent filter in Control Flow and Resources view<\/li>\r\n\t<li>\r\n\t\tSupport for refreshing of local traces<\/li>\r\n\t<li>\r\n\t\tTrace indexing improvement<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 1.2 is a minor release that ships with the Mars.2 update release.<\/p>\n","summary":"","value":"<p><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">Trace Compass 1.2 is a minor release that ships with the Mars.2 <\/span><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">update release.<\/span><\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n","value":"<p><span style=\"font-size:12px;\">We have no end-of-life issues to discuss at this time.<\/span><\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n<p> <\/p>\n","value":"<p><span style=\"font-size:12px;\">Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/span><\/p>\r\n<p>&nbsp;<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn12"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2016-02-17 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"1.2.0"}],"state":[{"value":"success"}],"title":"1.2.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/1.2.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p><span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\"><span style=\"font-size:12px;\">There are no security issues<\/span>.<\/span><\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n\t\t<a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a>\n<ul><li>\n\t\t\t\tLinux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/li>\n<li>\n\t\t\t\tLinux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\n<li>\n\t\t\t\tOther traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\n<\/ul><\/li>\n<li>\n\t\t<a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/li>\n<li>\n\t\t<a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/li>\n<li>\n\t\tThe <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\n","value":"<p><span style=\"font-size:12px;\">Trace Compass comes with multipe built-in trace parsers for the following standard:<\/span><\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\"><a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a><\/span>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-size:12px;\">Linux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-size:12px;\">Linux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/span><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<span style=\"font-size:12px;\">Other traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/span><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\"><a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\"><a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">The <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/span><\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:12px;\">Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/span><\/p>\r\n"}],"subprojects":[],"themes":[],"title":"1.2.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/1.2.0","usability":[{"format":"full_html","safe_value":"<ul><li>\n\t\tTrace Compass aims to conform to the Eclipse user interface guidelines.<\/li>\n<li>\n\t\tThe UI components support for keyboard navigation.<\/li>\n<li>\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\n<li>\n\t\tTrace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/li>\n<\/ul><p>User experience is very important for us and we continuously work on improving the user experience.<\/p>\n","value":"<ul>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Trace Compass aims to conform to the Eclipse user interface guidelines.<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">The UI components support for keyboard navigation.<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">All of our strings are externalized but there are currently no language packs.<\/span><\/li>\r\n\t<li>\r\n\t\t<span style=\"font-size:12px;\">Trace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/span><\/li>\r\n<\/ul>\r\n<p><span style=\"font-size:12px;\">User experience is very important for us and we continuously work on improving the user experience.<\/span><\/p>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>No architectural changes for this release.<\/p>\n","value":"<p>No architectural changes for this release.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n\t\t6 active committers from 3 different organizations<\/li>\n<li>\n\t\tTrace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/li>\n<li>\n\t\tUser interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/li>\n<li>\n\t\tBugzilla is used for planning and bug tracking<\/li>\n<li>\n\t\tCentralized update site and download page for the standalone RCP<\/li>\n<li>\n\t\tTrace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/li>\n<li>\n\t\tStrong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/li>\n<li>\n\t\tMany interactions with the CDT project. One committer is also committer in CDT.<\/li>\n<li>\n\t\tTrace Compass is the preferred Trace Analysis Tool for students as part of the trace research projects (see bullets below) with the Polytechnique Montreal university. Many enhancements for Trace Compass are an outcome of these reseach projects.\n<ul><li>\n\t\t\t\t<a href=\"https:\/\/ahls.dorsal.polymtl.ca\/\">Online Surveillance of Critical Computer Systems Through Advanced Host-Based Detection<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"http:\/\/ctpd.dorsal.polymtl.ca\/\">Integrated tracing, profiling and debugging for tuning large heterogeneous clusters<\/a><\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t6 active committers from 3 different organizations<\/li>\r\n\t<li>\r\n\t\tTrace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/li>\r\n\t<li>\r\n\t\tUser interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/li>\r\n\t<li>\r\n\t\tBugzilla is used for planning and bug tracking<\/li>\r\n\t<li>\r\n\t\tCentralized update site and download page for the standalone RCP<\/li>\r\n\t<li>\r\n\t\tTrace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/li>\r\n\t<li>\r\n\t\tStrong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/li>\r\n\t<li>\r\n\t\tMany interactions with the CDT project. One committer is also committer in CDT.<\/li>\r\n\t<li>\r\n\t\tTrace Compass is the preferred Trace Analysis Tool for students as part of the trace research projects (see bullets below) with the Polytechnique Montreal university. Many enhancements for Trace Compass are an outcome of these reseach projects.\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/ahls.dorsal.polymtl.ca\/\">Online Surveillance of Critical Computer Systems Through Advanced Host-Based Detection<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"http:\/\/ctpd.dorsal.polymtl.ca\/\">Integrated tracing, profiling and debugging for tuning large heterogeneous clusters<\/a><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-09-25 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>Trace Compass 1.1 focuses on bug fixes and new features such as:<\/p>\n<ul><li>\n\t\tEvents Table Enhancements\n<ul><li>\n\t\t\t\tSupport for hiding of columns<\/li>\n<li>\n\t\t\t\tCopy to clipboard<\/li>\n<li>\n\t\t\t\tPeriodic update during scrollbar drag in Events Table<\/li>\n<\/ul><\/li>\n<li>\n\t\tSupport for compressed traces (GZIP)<\/li>\n<li>\n\t\tLost event handling improvement<\/li>\n<\/ul>","value":"<p>Trace Compass 1.1 focuses on bug fixes and new features such as:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tEvents Table Enhancements\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for hiding of columns<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tCopy to clipboard<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tPeriodic update during scrollbar drag in Events Table<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tSupport for compressed traces (GZIP)<\/li>\r\n\t<li>\r\n\t\tLost event handling improvement<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass 1.1 is a minor release that ships with the Mars.1 update release.<\/p>\n","summary":"","value":"<p><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">Trace Compass 1.1 is a minor release that ships with the Mars.1&nbsp;<\/span><span style=\"box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">update release.<\/span><\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\n","value":"<p>We have no end-of-life issues to discuss at this time.<\/p>\r\n"}],"environment":[],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n<p>User Guides<\/p>\n<ul><li>\n\t\tLTTng User Guide  (including generic framework features)<\/li>\n<li>\n\t\tPcap Network Analysis User Guide<\/li>\n<li>\n\t\tGDBTrace Analysis User Guide<\/li>\n<li>\n\t\tTrace Compass Product User Guide (RCP)<\/li>\n<\/ul><p>Developer Guide<\/p>\n<ul><li>\n\t\tTrace Compass Developer Guide<\/li>\n<\/ul>","value":"<p>Trace Compass documentation is kept up-to-date for added and changed features. The developer and user guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n<p>User Guides<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tLTTng User Guide&nbsp; (including generic framework features)<\/li>\r\n\t<li>\r\n\t\tPcap Network Analysis User Guide<\/li>\r\n\t<li>\r\n\t\tGDBTrace Analysis User Guide<\/li>\r\n\t<li>\r\n\t\tTrace Compass Product User Guide (RCP)<\/li>\r\n<\/ul>\r\n<p>Developer Guide<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tTrace Compass Developer Guide<\/li>\r\n<\/ul>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn11"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2015-09-16 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"1.1.0"}],"state":[{"value":"success"}],"title":"1.1.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/1.1.0-release-review"},"screenshots":[],"security":[{"format":"full_html","safe_value":"<p>There are no security issues.<\/p>\n","value":"<p><span style=\"color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;\">There are no security issues.<\/span><\/p>\r\n"}],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n\t\t<a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a>\n<ul><li>\n\t\t\t\tLinux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/li>\n<li>\n\t\t\t\tLinux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\n<li>\n\t\t\t\tOther traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\n<\/ul><\/li>\n<li>\n\t\t<a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/li>\n<li>\n\t\t<a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/li>\n<li>\n\t\tThe <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\n","value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tLinux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tLinux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tOther traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/li>\r\n\t<li>\r\n\t\t<a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/li>\r\n\t<li>\r\n\t\tThe <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/li>\r\n<\/ul>\r\n<p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\r\n"}],"subprojects":[],"themes":[],"title":"1.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/1.1.0","usability":[{"format":"full_html","safe_value":"<ul><li>\n\t\tTrace Compass aims to conform to the Eclipse user interface guidelines.<\/li>\n<li>\n\t\tThe UI components support for keyboard navigation.<\/li>\n<li>\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\n<li>\n\t\tTrace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/li>\n<\/ul><p>We continuously work on improving the user experience. This 1.1 release provides user facing improvements, for example:<\/p>\n<ul><li>\n\t\tEvents Table Enhancements\n<ul><li>\n\t\t\t\tSupport for hiding of columns<\/li>\n<li>\n\t\t\t\tCopy to clipboard<\/li>\n<li>\n\t\t\t\tPeriodic update during scrollbar drag in Events Table<\/li>\n<\/ul><\/li>\n<li>\n\t\tSupport for compressed traces (GZIP)<\/li>\n<li>\n\t\tLost event handling improvement which helps user detecting time ranges where trace events were lost<\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\tTrace Compass aims to conform to the Eclipse user interface guidelines.<\/li>\r\n\t<li>\r\n\t\tThe UI components support for keyboard navigation.<\/li>\r\n\t<li>\r\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\r\n\t<li>\r\n\t\tTrace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/li>\r\n<\/ul>\r\n<p>We continuously work on improving the user experience. This 1.1 release provides user facing improvements, for example:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tEvents Table Enhancements\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tSupport for hiding of columns<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tCopy to clipboard<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tPeriodic update during scrollbar drag in Events Table<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tSupport for compressed traces (GZIP)<\/li>\r\n\t<li>\r\n\t\tLost event handling improvement which helps user detecting time ranges where trace events were lost<\/li>\r\n<\/ul>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\n<p>This is the first major release for this project after moving the source code from Eclipse Linux Tools project and after the initial Trace Compass 0.1.0 release.<\/p>\n<p>With this release the project will go out of Incubation.<\/p>\n<p>Trace Compass provides an extensible framework written in Java that exposes a generic interface for the integration of logs or trace data input. This enables developers can extend the framework for their application specifics. For that, Trace Compass provides extension points for<\/p>\n<ul><li>\n\t\tadding support for new trace and log formats<\/li>\n<li>\n\t\tadding support for custom trace analysis modules<\/li>\n<li>\n\t\tadding support for custom UI elements such as events tables, analyses output and sequence diagrams<\/li>\n<\/ul><p>Trace Compass also provides support for custom parsers, data-driven analyses and views. Custom text or XML parsers can be added directly from the graphical interface by the user. Configurable, data-driven analyses and views can be defined in XML and then be loaded to enhance the functionality of Trace Compass.<\/p>\n","value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\r\n<p>This is the first major release for this project after moving the source code from Eclipse Linux Tools project and after the initial Trace Compass 0.1.0 release.<\/p>\r\n<p>With this release the project will go out of Incubation.<\/p>\r\n<p>Trace Compass provides an extensible framework written in Java that exposes a generic interface for the integration of logs or trace data input. This enables developers can extend the framework for their application specifics. For that, Trace Compass provides extension points for<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tadding support for new trace and log formats<\/li>\r\n\t<li>\r\n\t\tadding support for custom trace analysis modules<\/li>\r\n\t<li>\r\n\t\tadding support for custom UI elements such as events tables, analyses output and sequence diagrams<\/li>\r\n<\/ul>\r\n<p>Trace Compass also provides support for custom parsers, data-driven analyses and views. Custom text or XML parsers can be added directly from the graphical interface by the user. Configurable, data-driven analyses and views can be defined in XML and then be loaded to enhance the functionality of Trace Compass.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n\t\t6 active committers from 3 different organizations<\/li>\n<li>\n\t\tTrace Compass can be setup using Oomph.  We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/li>\n<li>\n\t\tUser interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/li>\n<li>\n\t\tBugzilla is used for planning and bug tracking<\/li>\n<li>\n\t\tCentralized update site and download page for the standalone RCP<\/li>\n<li>\n\t\tTrace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/li>\n<li>\n\t\tStrong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/li>\n<li>\n\t\tMany interactions with the CDT project. One committer is also committer in CDT.<\/li>\n<li>\n\t\tTrace Compass is the preferred Trace Analysis Tool for students as part of the trace research projects (see bullets below) with the Polytechnique Montreal university. Many enhancements for Trace Compass are an outcome of these reseach projects.\n<ul><li>\n\t\t\t\t<a href=\"https:\/\/ahls.dorsal.polymtl.ca\/\">Online Surveillance of Critical Computer Systems Through Advanced Host-Based Detection<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"http:\/\/ctpd.dorsal.polymtl.ca\/\">Integrated tracing, profiling and debugging for tuning large heterogeneous clusters<\/a><\/li>\n<\/ul><\/li>\n<li>\n\t\tProject members are regularly presenting at EclipseCon North America and Europe as well as at the Tracing Summit that co-hosted with LinuxCon, for example:\n<ul><li>\n\t\t\t\t<a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014TraceCompass\">From Network to Application: Understanding Your Distributed System with Trace Compass<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/europe2014\/session\/trace-compass-finding-your-way-through-all-sorts-traces\">Trace Compass: Finding Your Way Through All Sorts of Traces<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2015\/session\/analyzing-eclipse-applications-trace-compass\">Tracing the innards of your application<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2015\/session\/great-troubleshooting-encounter-cdt-meets-trace-compass\">The great troubleshooting encounter: CDT meets Trace Compass<\/a><\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t6 active committers from 3 different organizations<\/li>\r\n\t<li>\r\n\t\tTrace Compass can be setup using Oomph. &nbsp;We hope this lowers the barrier-to-entry and stimulates the growth of our community.<\/li>\r\n\t<li>\r\n\t\tUser interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/li>\r\n\t<li>\r\n\t\tBugzilla is used for planning and bug tracking<\/li>\r\n\t<li>\r\n\t\tCentralized update site and download page for the standalone RCP<\/li>\r\n\t<li>\r\n\t\tTrace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/li>\r\n\t<li>\r\n\t\tStrong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/li>\r\n\t<li>\r\n\t\tMany interactions with the CDT project. One committer is also committer in CDT.<\/li>\r\n\t<li>\r\n\t\tTrace Compass is the preferred Trace Analysis Tool for students as part of the trace research projects (see bullets below) with the Polytechnique Montreal university. Many enhancements for Trace Compass are an outcome of these reseach projects.\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/ahls.dorsal.polymtl.ca\/\">Online Surveillance of Critical Computer Systems Through Advanced Host-Based Detection<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"http:\/\/ctpd.dorsal.polymtl.ca\/\">Integrated tracing, profiling and debugging for tuning large heterogeneous clusters<\/a><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\tProject members are regularly presenting at EclipseCon North America and Europe as well as at the Tracing Summit that co-hosted with LinuxCon, for example:\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014TraceCompass\">From Network to Application: Understanding Your Distributed System with Trace Compass<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/europe2014\/session\/trace-compass-finding-your-way-through-all-sorts-traces\">Trace Compass: Finding Your Way Through All Sorts of Traces<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2015\/session\/analyzing-eclipse-applications-trace-compass\">Tracing the innards of your application<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2015\/session\/great-troubleshooting-encounter-cdt-meets-trace-compass\">The great troubleshooting encounter: CDT meets Trace Compass<\/a><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>The Trace Compass projects provides an extensible framework for building trace analyses and visualization tools. This comes with Eclipse plug-ins facilitates the addition of new analysis and views as well as generic interfaces for integration of  new trace data inputs, analyses and views. The API has been modified to streamline the generic interfaces and provide new capabilities.<\/p>\n<p>\t\tDevelopers that have been extending the functionality prior Trace Compass will have to adjust their code base to these changes.<\/p>\n<p>Users however, will be able to re-use their workspaces after upgrading to Trace Compass because all the extension point definitions were kept backwards compatible.<\/p>\n<p>Selected Trace Compass features (e.g. Linux Kernel Analysis) are part of the Eclipse IDE for C\/C++ Developers. It will be possible to upgrade from previous EPP builds that include the orignal featues which were part of the Eclipse Linux Tools project.<\/p>\n<p>Note, that this release requires Java 7 and Eclipse 4.5<\/p>\n","value":"<div class=\"field-items\">\r\n\t<div class=\"field-item even\">\r\n\t\t<p>The Trace Compass projects provides an extensible framework for building trace analyses and visualization tools. This comes with Eclipse plug-ins facilitates the addition of new analysis and views as well as generic interfaces for integration of&nbsp; new trace data inputs, analyses and views. The API has been modified to streamline the generic interfaces and provide new capabilities.<\/p>\r\n\t\tDevelopers that have been extending the functionality prior Trace Compass will have to adjust their code base to these changes.\r\n\t\t<p>Users however, will be able to re-use their workspaces after upgrading to Trace Compass because all the extension point definitions were kept backwards compatible.<\/p>\r\n\t\t<p>Selected Trace Compass features (e.g. Linux Kernel Analysis) are part of the Eclipse IDE for C\/C++ Developers. It will be possible to upgrade from previous EPP builds that include the orignal featues which were part of the Eclipse Linux Tools project.<\/p>\r\n\t<\/div>\r\n<\/div>\r\n<p>Note, that this release requires Java 7 and Eclipse 4.5<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-06-24 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>This is the first major release for this project after moving the source code from Eclipse Linux Tools project and after the initial Trace Compass 0.1.0 release.<\/p>\n<p>This release continues providing a framework for building trace analysis and visualization tools as well as built-in trace parsers (e.g. for Common Trace Format CTF) and built-in analyses and views.<\/p>\n<p>New features in this release focus on the user experience For example, the following enhancement have been added:<\/p>\n<ul><li>\n\t\tAligned time axis for time based view<\/li>\n<li>\n\t\tCustomizable fonts and color for Events Table using preferences.<\/li>\n<li>\n\t\tColor highlighting of search and filter matches in Events Table<\/li>\n<li>\n\t\tPersistent column order in Events Table for user preferred column order<\/li>\n<li>\n\t\tControl flow view filtering enhancement<\/li>\n<\/ul><p>A new framework component for adding remote capabilites have been added. This component can be used for uploading and downloading traces and configuration files to or from a remote host. Also it provides an API for implementing tracer control features. It is currently used for the LTTng control view implementation.<\/p>\n<p> <\/p>\n","value":"<p>This is the first major release for this project after moving the source code from Eclipse Linux Tools project and after the initial Trace Compass 0.1.0 release.<\/p>\r\n<p>This release continues providing a framework for building trace analysis and visualization tools as well as built-in trace parsers (e.g. for Common Trace Format CTF) and built-in analyses and views.<\/p>\r\n<p>New features in this release focus on the user experience For example, the following enhancement have been added:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tAligned time axis for time based view<\/li>\r\n\t<li>\r\n\t\tCustomizable fonts and color for Events Table using preferences.<\/li>\r\n\t<li>\r\n\t\tColor highlighting of search and filter matches in Events Table<\/li>\r\n\t<li>\r\n\t\tPersistent column order in Events Table for user preferred column order<\/li>\r\n\t<li>\r\n\t\tControl flow view filtering enhancement<\/li>\r\n<\/ul>\r\n<p>A new framework component for adding remote capabilites have been added. This component can be used for uploading and downloading traces and configuration files to or from a remote host. Also it provides an API for implementing tracer control features. It is currently used for the LTTng control view implementation.<\/p>\r\n<p>&nbsp;<\/p>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\n<p>This is the first major release for this project after moving the source code from Eclipse Linux Tools project.<\/p>\n","summary":"","value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\r\n<p>This is the first major release for this project after moving the source code from Eclipse Linux Tools project.<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>No end-of-life issues to discuss at this time.<\/p>\n","value":"<p>No end-of-life issues to discuss at this time.<\/p>\r\n"}],"environment":[{"format":"full_html","safe_value":"<p>Trace Compass plug-ins and the standalone RCP will be available for Linux (32\/64 bit), Windows (32\/64bit) and MacOS. The required Java version is Java 7.<\/p>\n","value":"<p>Trace Compass plug-ins and the standalone RCP will be available for Linux (32\/64 bit), Windows (32\/64bit) and MacOS. The required Java version is Java 7.<\/p>\r\n"}],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass provides documentation in form of User and Developer Guides. The developer guide explains how to extend the framework and provides several tutorials for that. These guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available as a wiki page on the Eclipse Foundation's <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\n<p>User Guides<\/p>\n<ul><li>\n\t\tLTTng User Guide  (including generic framework features)<\/li>\n<li>\n\t\tPcap Network Analysis User Guide<\/li>\n<li>\n\t\tGDBTrace Analysis User Guide<\/li>\n<li>\n\t\tTrace Compass Product User Guide (RCP)<\/li>\n<\/ul><p>Developer Guide<\/p>\n<ul><li>\n\t\tTrace Compass Developer Guide<\/li>\n<\/ul><p><a href=\"https:\/\/git.eclipse.org\/r\/#\/q\/project:tracecompass\/org.eclipse.tracecompass+-status:draft\">Gerrit<\/a> is used for all internal and external contributions. The contributions are build on the <a href=\"https:\/\/hudson.eclipse.org\/tracecompass\/\">HIPP<\/a> for Trace Compass. <a href=\"https:\/\/dev.eclipse.org\/sonar\/dashboard\/index\/org.eclipse.tracecompass:org.eclipse.tracecompass\">Sonar<\/a> is used to monitor quality metrics. The performance is monitored through the Eclipse performance framework and visualized <a href=\"http:\/\/istmffastyet.dorsal.polymtl.ca\/\">here<\/a>.<\/p>\n","value":"<p>Trace Compass provides documentation in form of User and Developer Guides. The developer guide explains how to extend the framework and provides several tutorials for that. These guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available as a wiki page on the Eclipse Foundation&#39;s <a href=\"https:\/\/wiki.eclipse.org\/Trace_Compass#User_Guides\">web page<\/a>.<\/p>\r\n<p>User Guides<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tLTTng User Guide&nbsp; (including generic framework features)<\/li>\r\n\t<li>\r\n\t\tPcap Network Analysis User Guide<\/li>\r\n\t<li>\r\n\t\tGDBTrace Analysis User Guide<\/li>\r\n\t<li>\r\n\t\tTrace Compass Product User Guide (RCP)<\/li>\r\n<\/ul>\r\n<p>Developer Guide<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tTrace Compass Developer Guide<\/li>\r\n<\/ul>\r\n<p><a href=\"https:\/\/git.eclipse.org\/r\/#\/q\/project:tracecompass\/org.eclipse.tracecompass+-status:draft\">Gerrit<\/a> is used for all internal and external contributions. The contributions are build on the <a href=\"https:\/\/hudson.eclipse.org\/tracecompass\/\">HIPP<\/a> for Trace Compass. <a href=\"https:\/\/dev.eclipse.org\/sonar\/dashboard\/index\/org.eclipse.tracecompass:org.eclipse.tracecompass\">Sonar<\/a> is used to monitor quality metrics. The performance is monitored through the Eclipse performance framework and visualized <a href=\"http:\/\/istmffastyet.dorsal.polymtl.ca\/\">here<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn10"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2015-06-10 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"1.0.0"}],"state":[{"value":"success"}],"title":"1.0.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"},{"value":"graduation"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/1.0.0-release-review"},"screenshots":[],"security":[],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n\t\t<a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a>\n<ul><li>\n\t\t\t\tLinux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/li>\n<li>\n\t\t\t\tLinux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\n<li>\n\t\t\t\tOther traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\n<\/ul><\/li>\n<li>\n\t\t<a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/li>\n<li>\n\t\t<a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/li>\n<li>\n\t\tThe <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\n","value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tLinux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tLinux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tOther traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/li>\r\n\t<li>\r\n\t\t<a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/li>\r\n\t<li>\r\n\t\tThe <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/li>\r\n<\/ul>\r\n<p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\r\n"}],"subprojects":[],"themes":[],"title":"1.0.0","type":[{"value":"1"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/1.0.0","usability":[{"format":"full_html","safe_value":"<ul><li>\n\t\tTrace Compass aims to conform to the Eclipse user interface guidelines.<\/li>\n<li>\n\t\tThe UI components support for keyboard navigation.<\/li>\n<li>\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\n<li>\n\t\tTrace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/li>\n<\/ul><p>We continuously work on improving the user experience. This 1.0 release added several user experince improvements, for example:<\/p>\n<ul><li>\n\t\tAligned time axis for time based view<\/li>\n<li>\n\t\tCustomizable fonts and color for Events Table<\/li>\n<li>\n\t\tHighlighting of matched search and flter matches in the Events Table<\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\tTrace Compass aims to conform to the Eclipse user interface guidelines.<\/li>\r\n\t<li>\r\n\t\tThe UI components support for keyboard navigation.<\/li>\r\n\t<li>\r\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\r\n\t<li>\r\n\t\tTrace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/li>\r\n<\/ul>\r\n<p>We continuously work on improving the user experience. This 1.0 release added several user experince improvements, for example:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tAligned time axis for time based view<\/li>\r\n\t<li>\r\n\t\tCustomizable fonts and color for Events Table<\/li>\r\n\t<li>\r\n\t\tHighlighting of matched search and flter matches in the Events Table<\/li>\r\n<\/ul>\r\n"}]},{"apis":[{"value":"1"}],"architecture":[{"format":"full_html","safe_value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\n<p>Trace Compass also provides an extensible framework written in Java that exposes a generic interface for the integration of logs or trace data input. This enables developers can extend the framework for their application specifics. For that, Trace Compass provides extension points for<\/p>\n<ul><li>\n\t\tadding support for new trace and log formats<\/li>\n<li>\n\t\tadding support for custom trace analysis modules<\/li>\n<li>\n\t\tadding support for custom UI elements such as events tables, analyses output and sequence diagrams<\/li>\n<\/ul><p>Trace Compass also provides support for custom parsers, data-driven analyses and views. Custom text or XML parsers can be added directly from the graphical interface by the user. Configurable, data-driven analyses and views can be defined in XML and then be loaded to enhance the functionality of Trace Compass.<\/p>\n","value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\r\n<p>Trace Compass also provides an extensible framework written in Java that exposes a generic interface for the integration of logs or trace data input. This enables developers can extend the framework for their application specifics. For that, Trace Compass provides extension points for<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tadding support for new trace and log formats<\/li>\r\n\t<li>\r\n\t\tadding support for custom trace analysis modules<\/li>\r\n\t<li>\r\n\t\tadding support for custom UI elements such as events tables, analyses output and sequence diagrams<\/li>\r\n<\/ul>\r\n<p>Trace Compass also provides support for custom parsers, data-driven analyses and views. Custom text or XML parsers can be added directly from the graphical interface by the user. Configurable, data-driven analyses and views can be defined in XML and then be loaded to enhance the functionality of Trace Compass.<\/p>\r\n"}],"communities":[{"format":"full_html","safe_value":"<ul><li>\n\t\t6 active committers from 2 different organizations<\/li>\n<li>\n\t\tUser interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/li>\n<li>\n\t\tBugzilla is used for planning and bug tracking<\/li>\n<li>\n\t\tCentralized update site and download page for the standalone RCP<\/li>\n<li>\n\t\tTrace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/li>\n<li>\n\t\tStrong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/li>\n<li>\n\t\tMany interactions with the CDT project. One committer is also committer in CDT.<\/li>\n<li>\n\t\tProject members are regularly presenting at EclipseCon North America and Europe as well as at the Tracing Summit that co-hosted with LinuxCon, for example:\n<ul><li>\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2014\/session\/looking-needle-haystack-use-eclipse-tmf\">Looking for a needle in a haystack? Use Eclipse TMF!<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2014\/session\/tracing-innards-your-application\">Tracing the innards of your application<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014TraceCompass\">From Network to Application: Understanding Your Distributed System with Trace Compass<\/a><\/li>\n<li>\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/europe2014\/session\/trace-compass-finding-your-way-through-all-sorts-traces\">Trace Compass: Finding Your Way Through All Sorts of Traces<\/a><\/li>\n<\/ul><\/li>\n<\/ul>","value":"<ul>\r\n\t<li>\r\n\t\t6 active committers from 2 different organizations<\/li>\r\n\t<li>\r\n\t\tUser interaction via Bugzilla, IRC chat (#tracecompass) and mailing list (ODMi3NoaH1ePMA/1@p4fU66ofpZBJTd5o)<\/li>\r\n\t<li>\r\n\t\tBugzilla is used for planning and bug tracking<\/li>\r\n\t<li>\r\n\t\tCentralized update site and download page for the standalone RCP<\/li>\r\n\t<li>\r\n\t\tTrace Compass is part of the <a href=\"http:\/\/www.polarsys.org\/solutions\/tracecompass\">PolarSys <\/a>solutions<\/li>\r\n\t<li>\r\n\t\tStrong relationship with the <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> project. Project members interact with this community via mailing list (FjfRdU4exjSw2Rwy@IZE6r71OFJeidmth)<\/li>\r\n\t<li>\r\n\t\tMany interactions with the CDT project. One committer is also committer in CDT.<\/li>\r\n\t<li>\r\n\t\tProject members are regularly presenting at EclipseCon North America and Europe as well as at the Tracing Summit that co-hosted with LinuxCon, for example:\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2014\/session\/looking-needle-haystack-use-eclipse-tmf\">Looking for a needle in a haystack? Use Eclipse TMF!<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/na2014\/session\/tracing-innards-your-application\">Tracing the innards of your application<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014TraceCompass\">From Network to Application: Understanding Your Distributed System with Trace Compass<\/a><\/li>\r\n\t\t\t<li>\r\n\t\t\t\t<a href=\"https:\/\/www.eclipsecon.org\/europe2014\/session\/trace-compass-finding-your-way-through-all-sorts-traces\">Trace Compass: Finding Your Way Through All Sorts of Traces<\/a><\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n<\/ul>\r\n"}],"compatibility":[{"format":"full_html","safe_value":"<p>The source code was moved from the Linux Tools source repository to the Trace Compass source repository. All java packages have been renamed to the directory structure of Trace Compass. Also some API changes have been made after the move to Trace Compass.<\/p>\n<p>Developers that have been extending the functionality prior Trace Compass will have to adjust their code base to these changes.<\/p>\n<p>Users however, will be able to re-use their workspaces after upgrading to Trace Compass because all the extension point definitions were kept backwards compatible.<\/p>\n<p>It will be also possible to upgrade an existing installation to Trace Compass using the release update site of Trace Compass.<\/p>\n","value":"<p>The source code was moved from the Linux Tools source repository to the Trace Compass source repository. All java packages have been renamed to the directory structure of Trace Compass. Also some API changes have been made after the move to Trace Compass.<\/p>\r\n<p>Developers that have been extending the functionality prior Trace Compass will have to adjust their code base to these changes.<\/p>\r\n<p>Users however, will be able to re-use their workspaces after upgrading to Trace Compass because all the extension point definitions were kept backwards compatible.<\/p>\r\n<p>It will be also possible to upgrade an existing installation to Trace Compass using the release update site of Trace Compass.<\/p>\r\n"}],"conf_ui_guidelines":[],"date":[{"date_type":"datetime","timezone":"America\/Montreal","timezone_db":"America\/Montreal","value":"2015-02-27 00:00:00"}],"deliverables":[{"format":"full_html","safe_value":"<p>This is the initial release for this project after moving the source code from Eclipse Linux Tools project. It will contain all the features that were present in up to the Linux Tools release 3.2.<\/p>\n<p><u><strong>Overview<\/strong><\/u><\/p>\n<ul><li>\n\t\tCan be integrated into Eclipse IDE or used as a standalone application. Eclipse plug-ins facilitates the addition of new analysis and views.<\/li>\n<li>\n\t\tProvides an extensible framework written in Java that exposes a generic interface for integration of logs or trace data input.<\/li>\n<li>\n\t\tCustom text or XML parsers can be added directly from the graphical interface by the user.<\/li>\n<li>\n\t\tExtendable to support various proprietary log or trace files.<\/li>\n<li>\n\t\tSupports live log and trace reading and monitoring.<\/li>\n<li>\n\t\tDesigned to be scalable: can handle traces that exceed available memory.<\/li>\n<li>\n\t\tRemote tracer configuration and control with built-in support for LTTng traces.<\/li>\n<li>\n\t\tTraces taken from different clocks can be correlated though event relationships.<\/li>\n<li>\n\t\tConfigurable, data-driven analyses and views<\/li>\n<\/ul><p><u><strong>Built-in Trace Format Support<\/strong><\/u><\/p>\n<ul><li>\n\t\tCommon Trace Format (CTF)<\/li>\n<li>\n\t\tLinux LTTng kernel traces (CTF)<\/li>\n<li>\n\t\tLinux LTTng-UST userspace traces (CTF) which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\n<li>\n\t\tLinux Perf traces (CTF)<\/li>\n<li>\n\t\tBare metal traces (CTF)<\/li>\n<li>\n\t\tHardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\n<li>\n\t\tGDB traces for debugging<\/li>\n<li>\n\t\tBest Trace Format for OSEK<\/li>\n<li>\n\t\tLibpcap (Packet CAPture) format, for network traces<\/li>\n<li>\n\t\tCustom text or XML parsers that can be added directly from the graphical interface by the user. Can be extended to support various proprietary log or trace fi les<\/li>\n<\/ul><p><u><strong>Built-In Analyses and Views<\/strong><\/u><\/p>\n<ul><li>\n\t\tMemory and Processor usage<\/li>\n<li>\n\t\tControl flow<\/li>\n<li>\n\t\tHardware and software resource allocation<\/li>\n<li>\n\t\tHistogram<\/li>\n<li>\n\t\tCall Stack<\/li>\n<li>\n\t\tNetwork Streams<\/li>\n<li>\n\t\tDetailed Events List<\/li>\n<li>\n\t\tTrace Statistics<\/li>\n<\/ul>","value":"<p>This is the initial release for this project after moving the source code from Eclipse Linux Tools project. It will contain all the features that were present in up to the Linux Tools release 3.2.<\/p>\r\n<p><u><strong>Overview<\/strong><\/u><\/p>\r\n<ul>\r\n\t<li>\r\n\t\tCan be integrated into Eclipse IDE or used as a standalone application. Eclipse plug-ins facilitates the addition of new analysis and views.<\/li>\r\n\t<li>\r\n\t\tProvides an extensible framework written in Java that exposes a generic interface for integration of logs or trace data input.<\/li>\r\n\t<li>\r\n\t\tCustom text or XML parsers can be added directly from the graphical interface by the user.<\/li>\r\n\t<li>\r\n\t\tExtendable to support various proprietary log or trace files.<\/li>\r\n\t<li>\r\n\t\tSupports live log and trace reading and monitoring.<\/li>\r\n\t<li>\r\n\t\tDesigned to be scalable: can handle traces that exceed available memory.<\/li>\r\n\t<li>\r\n\t\tRemote tracer configuration and control with built-in support for LTTng traces.<\/li>\r\n\t<li>\r\n\t\tTraces taken from different clocks can be correlated though event relationships.<\/li>\r\n\t<li>\r\n\t\tConfigurable, data-driven analyses and views<\/li>\r\n<\/ul>\r\n<p><u><strong>Built-in Trace Format Support<\/strong><\/u><\/p>\r\n<ul>\r\n\t<li>\r\n\t\tCommon Trace Format (CTF)<\/li>\r\n\t<li>\r\n\t\tLinux LTTng kernel traces (CTF)<\/li>\r\n\t<li>\r\n\t\tLinux LTTng-UST userspace traces (CTF) which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\r\n\t<li>\r\n\t\tLinux Perf traces (CTF)<\/li>\r\n\t<li>\r\n\t\tBare metal traces (CTF)<\/li>\r\n\t<li>\r\n\t\tHardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\r\n\t<li>\r\n\t\tGDB traces for debugging<\/li>\r\n\t<li>\r\n\t\tBest Trace Format for OSEK<\/li>\r\n\t<li>\r\n\t\tLibpcap (Packet CAPture) format, for network traces<\/li>\r\n\t<li>\r\n\t\tCustom text or XML parsers that can be added directly from the graphical interface by the user. Can be extended to support various proprietary log or trace fi les<\/li>\r\n<\/ul>\r\n<p><u><strong>Built-In Analyses and Views<\/strong><\/u><\/p>\r\n<ul>\r\n\t<li>\r\n\t\tMemory and Processor usage<\/li>\r\n\t<li>\r\n\t\tControl flow<\/li>\r\n\t<li>\r\n\t\tHardware and software resource allocation<\/li>\r\n\t<li>\r\n\t\tHistogram<\/li>\r\n\t<li>\r\n\t\tCall Stack<\/li>\r\n\t<li>\r\n\t\tNetwork Streams<\/li>\r\n\t<li>\r\n\t\tDetailed Events List<\/li>\r\n\t<li>\r\n\t\tTrace Statistics<\/li>\r\n<\/ul>\r\n"}],"description":[{"format":"full_html","safe_summary":"","safe_value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\n<p>This is the initial release for this project after moving the source code from Eclipse Linux Tools project.<\/p>\n<p>The Trace Compass release will provide an update site for installing its features on top of an existing Eclipse installation as well as a standalone RCP.<\/p>\n<p> <\/p>\n","summary":"","value":"<p>Trace Compass is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative.<\/p>\r\n<p>This is the initial release for this project after moving the source code from Eclipse Linux Tools project.<\/p>\r\n<p>The Trace Compass release will provide an update site for installing its features on top of an existing Eclipse installation as well as a standalone RCP.<\/p>\r\n<p>&nbsp;<\/p>\r\n"}],"endoflife":[{"format":"full_html","safe_value":"<p>No end-of-life issues to discuss at this time.<\/p>\n","value":"<p>No end-of-life issues to discuss at this time.<\/p>\r\n"}],"environment":[{"format":"full_html","safe_value":"<p>Trace Compass plug-ins and the standalone RCP will be available for Linux (32\/64 bit), Windows (32\/64bit) and MacOS. The required Java version is Java 7.<\/p>\n","value":"<p>Trace Compass plug-ins and the standalone RCP will be available for Linux (32\/64 bit), Windows (32\/64bit) and MacOS. The required Java version is Java 7.<\/p>\r\n"}],"i18n":[],"ip_due_diligence_type":[],"milestones":[],"noncode":[{"format":"full_html","safe_value":"<p>Trace Compass provides documentation in form of User and Developer Guides. The developer guide explains how to extend the framework and provides several tutorials for that. These guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available as a wiki page on the Eclipse Foundation's web page.<\/p>\n<p>User Guides<\/p>\n<ul><li>\n\t\tLTTng User Guide  (including generic framework features)<\/li>\n<li>\n\t\tPcap Network Analysis User Guide<\/li>\n<li>\n\t\tGDBTrace Analysis User Guide<\/li>\n<li>\n\t\tTrace Compass Product User Guide (RCP)<\/li>\n<\/ul><p>Developer Guide<\/p>\n<ul><li>\n\t\tTrace Compass Developer Guide<\/li>\n<\/ul><p><a href=\"https:\/\/git.eclipse.org\/r\/#\/q\/project:tracecompass\/org.eclipse.tracecompass+-status:draft\">Gerrit<\/a> is used for all internal and external contributions. The contributions are build on the <a href=\"https:\/\/hudson.eclipse.org\/tracecompass\/\">HIPP<\/a> for Trace Compass. <a href=\"https:\/\/dev.eclipse.org\/sonar\/dashboard\/index\/org.eclipse.tracecompass:org.eclipse.tracecompass\">Sonar<\/a> is used to monitor quality metrics. The performance is monitored through the Eclipse performance framework and visualized <a href=\"http:\/\/istmffastyet.dorsal.polymtl.ca\/\">here<\/a>.<\/p>\n","value":"<p>Trace Compass provides documentation in form of User and Developer Guides. The developer guide explains how to extend the framework and provides several tutorials for that. These guides are available as Eclipse help plug-ins and are part of the installable features. The latest released versions are also available as a wiki page on the Eclipse Foundation&#39;s web page.<\/p>\r\n<p>User Guides<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tLTTng User Guide&nbsp; (including generic framework features)<\/li>\r\n\t<li>\r\n\t\tPcap Network Analysis User Guide<\/li>\r\n\t<li>\r\n\t\tGDBTrace Analysis User Guide<\/li>\r\n\t<li>\r\n\t\tTrace Compass Product User Guide (RCP)<\/li>\r\n<\/ul>\r\n<p>Developer Guide<\/p>\r\n<ul>\r\n\t<li>\r\n\t\tTrace Compass Developer Guide<\/li>\r\n<\/ul>\r\n<p><a href=\"https:\/\/git.eclipse.org\/r\/#\/q\/project:tracecompass\/org.eclipse.tracecompass+-status:draft\">Gerrit<\/a> is used for all internal and external contributions. The contributions are build on the <a href=\"https:\/\/hudson.eclipse.org\/tracecompass\/\">HIPP<\/a> for Trace Compass. <a href=\"https:\/\/dev.eclipse.org\/sonar\/dashboard\/index\/org.eclipse.tracecompass:org.eclipse.tracecompass\">Sonar<\/a> is used to monitor quality metrics. The performance is monitored through the Eclipse performance framework and visualized <a href=\"http:\/\/istmffastyet.dorsal.polymtl.ca\/\">here<\/a>.<\/p>\r\n"}],"noteworthy":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass\/News\/NewIn010"}],"parent_project":[{"id":"tools.tracecompass"}],"review":{"description":[],"end_date":[{"date_type":"datetime","timezone":"Europe\/Berlin","timezone_db":"Europe\/Berlin","value":"2015-02-25 00:00:00"}],"links":[],"project":[{"id":"tools.tracecompass"}],"reference":[{"title":"0.1.0"}],"state":[{"value":"success"}],"title":"0.1.0 Release Review","top_level":[{"id":"tools"}],"type":[{"value":"release"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/reviews\/0.1.0-release-review"},"screenshots":[],"security":[],"standards":[{"format":"full_html","safe_value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\n<ul><li>\n\t\t<a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a>\n<ul><li>\n\t\t\t\tLinux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/li>\n<li>\n\t\t\t\tLinux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\n<li>\n\t\t\t\tOther traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\n<\/ul><\/li>\n<li>\n\t\t<a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/li>\n<li>\n\t\t<a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/li>\n<li>\n\t\tThe <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/li>\n<\/ul><p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\n","value":"<p>Trace Compass comes with multipe built-in trace parsers for the following standard:<\/p>\r\n<ul>\r\n\t<li>\r\n\t\t<a href=\"http:\/\/www.efficios.com\/ctf\">Common Trace Format (CTF)<\/a>\r\n\t\t<ul>\r\n\t\t\t<li>\r\n\t\t\t\tLinux <a href=\"http:\/\/tracingsummit.org\/wiki\/TracingSummit2014\">LTTng<\/a> kernel traces<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tLinux <a href=\"https:\/\/lttng.org\/ust\">LTTng-UST<\/a> userspace traces which can come from proprietary software or open source eg. Mir, MariaDB, QEMU traces<\/li>\r\n\t\t\t<li>\r\n\t\t\t\tOther traces in CTF, e.g. Linux Perf traces (CTF), Bare metal traces (CTF), Hardware traces (e.g. IEEE Nexus 5001 CTF conversion).<\/li>\r\n\t\t<\/ul>\r\n\t<\/li>\r\n\t<li>\r\n\t\t<a href=\"https:\/\/sourceware.org\/gdb\/onlinedocs\/gdb\/Tracepoints.html\">GDB traces<\/a> for debugging<\/li>\r\n\t<li>\r\n\t\t<a href=\"https:\/\/wiki.eclipse.org\/images\/e\/e6\/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf\">Best Trace Format<\/a> for OSEK<\/li>\r\n\t<li>\r\n\t\tThe <a href=\"http:\/\/wiki.wireshark.org\/Development\/LibpcapFileFormat\">libpcap<\/a> (PAcket CAPture) format, for network traces<\/li>\r\n<\/ul>\r\n<p>Trace Compass provides a remote tracer control for <a href=\"https:\/\/lttng.org\/\">LTTng<\/a> Kernel and UST Tracers for configuring of trace sessions.<\/p>\r\n"}],"subprojects":[],"themes":[],"title":"0.1.0","type":[{"value":"2"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass\/releases\/0.1.0","usability":[{"format":"full_html","safe_value":"<ul><li>\n\t\tTrace Compass aims to conform to the Eclipse user interface guidelines.<\/li>\n<li>\n\t\tThe UI components support for keyboard navigation.<\/li>\n<li>\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\n<li>\n\t\tTrace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/li>\n<\/ul><p> <\/p>\n","value":"<ul>\r\n\t<li>\r\n\t\tTrace Compass aims to conform to the Eclipse user interface guidelines.<\/li>\r\n\t<li>\r\n\t\tThe UI components support for keyboard navigation.<\/li>\r\n\t<li>\r\n\t\tAll of our strings are externalized but there are currently no language packs.<\/li>\r\n\t<li>\r\n\t\tTrace Compass is designed to support large trace data that exceeds the available memory while providing a responsive UI.<\/li>\r\n<\/ul>\r\n<p>&nbsp;<\/p>\r\n"}]}],"scope":[{"format":"filtered_html","safe_value":"<p>Eclipse Trace Compass™ is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative. The project provides:<\/p>\n<ul><li>Both a stand-alone RCP application and a standard Eclipse plugin.<\/li>\n<li>A core framework written in Java that exposes a generic interface for integration of logs or trace data input.<\/li>\n<li>Parsers to ingest input logs or traces and convert to the frameworks internal data representation.<\/li>\n<li>Support for the following trace formats natively (no third-party libraries needed):\n<ul><li>Linux LTTng kernel traces<\/li>\n<li>Linux LTTng-UST userspace traces<\/li>\n<li>Other traces in the Common Trace Format (CTF), like bare metal and HW traces (e.g. IEEE Nexus 5001 conversion). See also this link.<\/li>\n<li>GDB traces for debugging<\/li>\n<li>The Best Trace Format (BTF) for OSEK<\/li>\n<li>The libpcap (PAcket CAPture) format, for network traces<\/li>\n<li>Custom text or XML parsers that can be added right from the graphical interface by the user<\/li>\n<li>Can be (and has been) extended to support various proprietary log or trace files.<\/li>\n<\/ul><\/li>\n<li>Support for live trace reading and monitoring.<\/li>\n<li>Tracer control (currently available for LTTng traces)<\/li>\n<li>Configurable data-driven views and analysis.<\/li>\n<li>A trace synchronization infrastructure, which allow matching traces taken from different hosts at the same time.<\/li>\n<li>A repository of application-specific or problem-specific modules of all known trace type integration plugins.<\/li>\n<\/ul><p>\nThe following items would be considered outside of the scope of this project:<\/p>\n<ul><li>Trace viewing and analyzing facilities that do not integrate with the base Trace Compass framework and \"do their own thing\". To prevent project bloat, reduce the maintenance burden, and encourage reusability, all views and analyses integrated in the project should use the Trace Compass framework.<\/li>\n<li>Parsers\/readers depending on native utilities or libraries. Parsers should be implemented in the framework, in Java, as much as possible. Keeping the native third-party libraries to a minimum makes distribution easier.<\/li>\n<\/ul>","value":"<p>Eclipse Trace Compass&trade; is a tool for viewing and analyzing both logs and traces. It provides views, graphs, metrics, etc. to help extract useful information from logs or traces, in a way that is user-friendly and informative. The project provides:<\/p>\r\n\r\n<ul>\r\n\t<li>Both a stand-alone RCP application and a standard Eclipse plugin.<\/li>\r\n\t<li>A core framework written in Java that exposes a generic interface for integration of logs or trace data input.<\/li>\r\n\t<li>Parsers to ingest input logs or traces and convert to the frameworks internal data representation.<\/li>\r\n\t<li>Support for the following trace formats natively (no third-party libraries needed):\r\n\t<ul>\r\n\t\t<li>Linux LTTng kernel traces<\/li>\r\n\t\t<li>Linux LTTng-UST userspace traces<\/li>\r\n\t\t<li>Other traces in the Common Trace Format (CTF), like bare metal and HW traces (e.g. IEEE Nexus 5001 conversion). See also this link.<\/li>\r\n\t\t<li>GDB traces for debugging<\/li>\r\n\t\t<li>The Best Trace Format (BTF) for OSEK<\/li>\r\n\t\t<li>The libpcap (PAcket CAPture) format, for network traces<\/li>\r\n\t\t<li>Custom text or XML parsers that can be added right from the graphical interface by the user<\/li>\r\n\t\t<li>Can be (and has been) extended to support various proprietary log or trace files.<\/li>\r\n\t<\/ul>\r\n\t<\/li>\r\n\t<li>Support for live trace reading and monitoring.<\/li>\r\n\t<li>Tracer control (currently available for LTTng traces)<\/li>\r\n\t<li>Configurable data-driven views and analysis.<\/li>\r\n\t<li>A trace synchronization infrastructure, which allow matching traces taken from different hosts at the same time.<\/li>\r\n\t<li>A repository of application-specific or problem-specific modules of all known trace type integration plugins.<\/li>\r\n<\/ul>\r\n\r\n<p><br \/>\r\nThe following items would be considered outside of the scope of this project:<\/p>\r\n\r\n<ul>\r\n\t<li>Trace viewing and analyzing facilities that do not integrate with the base Trace Compass framework and &quot;do their own thing&quot;. To prevent project bloat, reduce the maintenance burden, and encourage reusability, all views and analyses integrated in the project should use the Trace Compass framework.<\/li>\r\n\t<li>Parsers\/readers depending on native utilities or libraries. Parsers should be implemented in the framework, in Java, as much as possible. Keeping the native third-party libraries to a minimum makes distribution easier.<\/li>\r\n<\/ul>\r\n"}],"source_repo":[{"name":"tracecompass\/org.eclipse.tracecompass","path":"\/gitroot\/tracecompass\/org.eclipse.tracecompass.git","type":"git","url":"https:\/\/git.eclipse.org\/r\/plugins\/gitiles\/tracecompass\/org.eclipse.tracecompass"}],"spec_working_group":[],"state":[{"value":"Regular"}],"tags":[],"team_project_sets":[],"techology_types":[{"tid":"24"}],"title":"Eclipse Trace Compass™","update_sites":[{"attributes":[],"title":"Release 7.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.3.0\/repository\/"},{"attributes":[],"title":"Release 7.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.2.0\/repository\/"},{"attributes":[],"title":"Release 7.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.1.0\/repository\/"},{"attributes":[],"title":"Release 7.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/7.0.0\/repository\/"},{"attributes":[],"title":"Release 6.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.3.0\/repository\/"},{"attributes":[],"title":"Release 6.2.1","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.2.1\/repository\/"},{"attributes":[],"title":"Release 6.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.2.0\/repository\/"},{"attributes":[],"title":"Release 6.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.1.0\/repository\/"},{"attributes":[],"title":"Release 6.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/6.0.0\/repository\/"},{"attributes":[],"title":"Release 5.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.3.0\/repository\/"},{"attributes":[],"title":"Release 5.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.2.0\/repository\/"},{"attributes":[],"title":"Release 5.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.1.0\/repository\/"},{"attributes":[],"title":"Release 5.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/5.0.0\/repository\/"},{"attributes":[],"title":"Release 4.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.3.0\/repository\/"},{"attributes":[],"title":"Release 4.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.2.0\/repository\/"},{"attributes":[],"title":"Release 4.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.1.0\/repository\/"},{"attributes":[],"title":"Release 4.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/4.0.0\/repository\/"},{"attributes":[],"title":"Release 3.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.3.0\/repository\/"},{"attributes":[],"title":"Release 3.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.2.0\/repository\/"},{"attributes":[],"title":"Release 3.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.1.0\/repository\/"},{"attributes":[],"title":"Release 3.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/3.0.0\/repository\/"},{"attributes":[],"title":"Release 2.3.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.3.0\/repository\/"},{"attributes":[],"title":"Release 2.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.2.0\/repository\/"},{"attributes":[],"title":"Release 2.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.1.0\/repository\/"},{"attributes":[],"title":"Release 2.0.1","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.0.1\/repository\/"},{"attributes":[],"title":"Release 2.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/2.0.0\/repository\/"},{"attributes":[],"title":"Release 1.2.1","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.2.1\/repository\/"},{"attributes":[],"title":"Release 1.2.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.2.0\/repository\/"},{"attributes":[],"title":"Release 1.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.1.0\/repository\/"},{"attributes":[],"title":"Release 1.0.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/1.0.0\/repository\/"},{"attributes":[],"title":"Release 0.1.0","url":"http:\/\/download.eclipse.org\/tracecompass\/releases\/0.1.0\/repository\/"},{"attributes":[],"title":"Latest stable builds","url":"http:\/\/download.eclipse.org\/tracecompass\/stable\/repository\/"},{"attributes":[],"title":"Nightly","url":"http:\/\/download.eclipse.org\/tracecompass\/master\/repository\/"}],"url":"https:\/\/projects.eclipse.org\/projects\/tools.tracecompass","website_url":[{"attributes":[],"title":null,"url":"https:\/\/www.eclipse.org\/tracecompass\/"}],"wiki_url":[{"attributes":[],"title":null,"url":"https:\/\/wiki.eclipse.org\/Trace_Compass"}],"working_group":[{"tid":"1535"}]},"pmi_url":"https:\/\/projects.eclipse.org\/json\/project\/tools.tracecompass"}