The TPTP Project is a Top-Level Project in Eclipse Foundation that was created by Eclipse Foundation in August 2004 as an evolution of the previous Eclipse ?Hyades? project. TPTP subsumes and extends the original Hyades Project that was created in late 2002. Refer to the TPTP website for further project details.
The scope of the original Hyades project has been partitioned into four new projects: The TPTP Platform, provides core elements and interoperability, and three others which leverage that infrastructure and relate to specific types of activity: TPTP Testing Tools, TPTP Tracing and Profiling Tools, and TPTP Monitoring Tools. Additional subprojects may be added, and new features and requirements are being added to each of the four projects.
The TPTP Project is managed by a Project Management Committee (PMC). The work of the Top Level Project is organized into Projects, each with its own Project Lead who is responsible for its success. Currently, over 40 Committers contribute to the Project development.
The goal of the project is to have the Eclipse Test & Performance Tools Platform to be recognized as a De Facto platform for test and performance tools by providing integration, interoperability, and common capabilities for software tools used throughout the application lifecycle.
The TPTP Project provides an open platform supplying powerful frameworks and services that allow software developers to build unique test and performance tools-both open source and commercial-that can be easily integrated with the platform and with other tools. The TPTP Platform addresses the entire test and performance lifecycle, from early testing to production application monitoring, including test editing and execution, monitoring, tracing and profiling, and log analysis capabilities. The platform supports a broad spectrum of computing systems including embedded, standalone, enterprise, and high-performance and will continue to expand support to encompass the widest possible range of systems. Full details of the Eclipse Test & Performance Tools Platform Project are available at www.eclipse.org/test-and-performance.
In an open source model, the cost of building the common infrastructure is shared amongst the participants in the project, and the diversity of intellectual inputs amongst Open Source Committers in open collaboration with their peers ensures that it is naturally based on Open Standards and can be best of breed. The focus on a shared infrastructure means the incremental cost of adding new features or supporting new platforms and environments is small, so the project itself can be nimble, and vendors leveraging the framework can accelerate the rate at which they add value to their own tools, thereby moving the overall Eclipse Ecosystem forward.
The following organizations are currently participating in the development of the project with Intel Corporation leading the TPTP Project.
The TPTP is concerned with the testing and performance of systems in general, although some special support is provided for systems built in Eclipse and for the Eclipse workbench itself. For example, the tests used to validate the TPTP infrastructure and tooling are stored in the Eclipse.org CVS repository in ways that can be managed and executed by tools that TPTP itself supplies. At this stage, TPTP is used to test TPTP and analyze performance of the Eclipse Platform and our intent is to drive more broad adoption of TPTP usage throughout Eclipse projects.
Yes. The project leverages core Eclipse subsystems such as SWT for user interfaces and EMF for data persistence, but there are elements of the TPTP infrastructure which operate in target environments which can be remote to the workbench, some of which are written in native code, rather than Java. User interfaces can be built as workbench clients, rich clients, and in some cases the infrastructure can operate without a user interface.
As is true in general for Eclipse, the project builds both infrastructure and Exemplary Extensible Tools. The open source distribution contains tools that will cover much of the basic activities of tracing, profiling, monitoring and testing, although this will probably primarily apply to small-scale systems, open source systems, and development environments rather than production systems. Individual vendors (both contributing Eclipse members, non-contributing members and non-members) may provide additional functionality through interfacing to the infrastructure, extending sample tools etc. They will also tend to provide support for the combined offering under commercial licensing arrangements.
The user interface components of the TPTP Infrastructure can run on any Eclipse-supported platform. The various test execution, monitoring and tracing components typically run on a broad range of infrastructure and interface with a broad range of systems. One notable deficiency at present is that the various trace facilities are currently Java-specific, although the project has a goal to extend additional language support in due course. For the other agents there is a reasonable coverage implemented or planned for popular operating systems, application servers, web servers etc, with a particular focus on providing support for other open source products.
The TPTP Project Marketing, Requirements, Architecture, and Planning Groups guide our project. Each of these groups is comprised of representatives from contributing organizations and aligned with respective Eclipse Foundation Committees.
Requirements are gathered from Eclipse member companies, research organizations, independent projects and projects hosted by the Eclipse Foundation. Feedback from these groups and investment in our meritocracy help prioritize implementation of the new technology in the Test and Performance Tools Platform as we take a generic view of how the frameworks could be reused. Ultimately, however, contributing organizations and individuals need to make long-term commitments to developing, documenting, testing and enhancing elements of the infrastructure, and new contributors are always welcome.
The projects that are hosted by Eclipse make all distributions available under licenses that are certified by the Open Software Initiative. TPTP Project distributions are made available under the combination of Common Public License (CPL) and Eclipse Public License (EPL) (transitioning to EPL in early 2005) which make the TPTP available for commercial re-distribution without royalty or the obligation to donate software back to Eclipse. See the licenses for more detail.
The TPTP Platform project covers the common infrastructure in the areas of user interface; EMF based data models, data collection and communications control, as well as remote execution environments. In addition, the platform provides the extension points for leveraging or extending the common infrastructure in solution specific tooling or runtime. This includes Eclipse workbench plug-ins as well as runtime plug-ins on a target and optionally remote system.
The TPTP Testing Tools project provides specializations of the platform for testing (e.g. test editors, trace/test conversion support), and exemplary extensible tools for specific testing environments. Initially this includes 3 test environments: JUnit, manual and URL testing. These specializations provide optimized editing and reporting experiences for these use cases.
The TPTP Tracing and Profiling Tools project extends the platform with specific data collection for Java and distributed applications that populate the common trace model, additional language and protocol support is anticipated. There are also viewers and analysis services that draw data from the common trace model. Capabilities are provided to collect and analyze both heap and stack information as well as generic toolkits for instrumenting running applications.
The TPTP Monitoring Tools project collects, analyzes, aggregates and visualizes data that can be captured in the log and statistical models. The typical examples are the collection of system or application resources such as CPU or memory utilization and support for the viewing, aggregation and analysis of that data. Logs can also be transformed into the common format and model allowing for symptom and pattern analysis. The correlation of the data in these models is of particular interest when it is associated with other model instances of statistical or log data as well as traces and tests.
The Data Models are abstract descriptions in UML of the types of assets (tests, traces, logs etc.) that the project deals with, and they are provided with a concrete implementation through the Eclipse Modeling Framework (EMF). This means that tools inside the Eclipse Workbench can manipulate objects which correspond to those abstract descriptions, which are managed and persisted inside the eclipse asset model and can be stored in projects, subjected to version control, etc. When they actually hit a file system they are in an open XMI format, but individual tools vendors don't have to go through the effort of manually constructing code to map that XMI into and out of an object format they can usefully manipulate, they merely speak to the EMF-generated API. Furthermore if two tools both speak to that API they can interoperate through shared use of the stored assets inside the asset management model provided by Eclipse.
The Test data model is based on an early draft of the UML 2 Test Profile (U2TP) defined by the Object Management Group. The Log Model is derived directly from a standard currently proposed at OASIS known as Common Base Event. The Trace Model is ad-hoc but maps quite closely to the data formats of JVMPI and JVMTI. The statistical model is also ad-hoc, but maps well onto the formats used by JMX and the Microsoft PerfMon counters.
Full details of the Eclipse Test & Performance Tools Platform Project are available at www.eclipse.org/tptp.
Back to the top