- 1 What is the Target Communication Framework (TCF)?
- 2 The TCF Protocol
- 3 The TCF Contribution
- 4 How does TCF compare to ECF?
- 5 How can I contribute to this FAQ?
What is the Target Communication Framework (TCF)?
The Target Communication Framework (TCF) is a new incubating component of the Eclipse Target Management Project. TCF is available on Eclipse SVN (ViewSVN access) and can easily be imported into a workspace with the tcf-anonymous.psf team project set. See bug 210751 for discussions leading to contributing TCF to Eclipse.
TCF is a vendor-neutral, lightweight, extensible network protocol mainly for communicating with embedded systems (targets). Its most distinguishing feature is that TCF is designed to transparently plug in value-adding servers between the tool and the target. But even without value-add, the protocol has potential to unify lots of currently independent communication links, thus saving resources and making setup and configuration much easier than in current embedded development scenarios.
The protocol has a transport-agnostic channel abstraction, so it does not depend on any specific transport such as TCP/IP, Serial Line, SSH tunnel or other. In fact, any 3rd party vendor can contribute a value-add server to do transport conversion from a standard TCP/IP channel into custom channels such as JTAG or even proprietary hardware connections: all services can immediately route through the new transport and take immediate benefit of the value-add.
TCF uses JSON as preferred data marshaling language and supports auto-discovery of targets and services. TCF is not restricted to Eclipse-based tools alone - there may be bindings to a variety of programming languages and environments. TCF is designed to become a replacement for protocols like GDB Serial, WDB, GDB/MI protocols used for embedded software development.
On top of the protocol specification, which is the core of TCF, the initial contribution includes a plain-C reference implementation of a lightweight extendable target agent with small footprint, as well as a Java client API (usable stand-alone or on top of Eclipse), documentation and usage examples. Future bindings may be for plain-C clients (like a gdb back-end plugin), tighter Eclipse integration (with the Eclipse Communication Framework (ECF)), or other.
For more details, see the Target_Communication_Framework_v3.ppt (400K) presentation, EclipseCon 2008 Tutorial on TM (slides and example code available there), EclipseCon 2008 Short Talk, or the architecture and design documents:
- Document Index
- TCF Project Overview - Project goals and results
- TCF Getting Started - Creating Eclipse workspace, building agent, making a first connection
- TCF Specifications - Design goals, requirements and format of TCF communication protocol, framework API and software design considerations
- TCF Services Definitions - TCF communication model is based on the idea of services. A service is a group of related commands, events and semantics. New services are expected to be defined by developers of tools and target agents. To achieve certain level of compatibility of tools/targets TCF inclides definitions of common services
- TCF Context Identifier Explanation - Most if not all TCF services functions need some way to identify what entity e.g. process, thread, task, device on JTAG scan chain, etc they should operate on. To do this TCF uses a context identifier (aka ContextId). This document is attempting to explain how ContextIds are intended to be used
- TCF Agent Prototype - Brief description of the TCF target agent prototype implementation
What is the current status of TCF?
- TCF is actively being developed on Eclipse SVN
- Use the TCF: Open Bugs query to see what bugs and enhancement requests are currently worked on
- Join the email@example.com mailing list for discussions and news about TCF
- The dsdp-tcf-dev mailing list also gets notified whenever a new bug or enhancement request is filed against TCF
- Join the firstname.lastname@example.org mailing list for general discussions about the Target Management project
- The EclipseCon 2008 TM Tutorial includes 1-hour in depth material about TCF, including sample code (available from the download site)
- TCF is ready to jump on - will remain in Incubation status for Ganymede but planned to go 1.0 with next year's Eclipse train
How can I get more involved?
- Ask questions on the email@example.com mailing list
- File a bug or enhancement request against TCF. This will automatically notify the dsdp-tcf-dev mailing list as well!
- Join one of the DSDP/TCF/Meetings on TCF, e.g.
The TCF Protocol
What is so special about the TCF protocol?
- TCF makes it simple to add value-adding servers into the host-target communication link: Instead of wrapping higher-level services like piggypack on top of lower ones, all services are on the same protocol layer. Therefore, servers can be plugged into the communication link transparently - no matter whether it's a hardware or software component. An example of a value-adding server is a debug engine providing translation between high-level language and assembly language debugging, or OS awareness adding information like which process or thread is currently executing when the target does not explicitly provide such information.
- TCF provides for tunneling, addressing and auto-discovery all through one single, simple protocol such that the target agent can be small and lightweight. A reference implementation of such a lightweight agent is included for Linux, Windows and VxWorks.
- There is a single abstraction for a "Channel" to support message-based host/target communication. Currently, channels are supported on TCP/IP only, but other communication and addressing schemes can be added easily. All higher-level services operate on the Channel abstraction.
- The Tool_Target_Communication_Vision_v5.ppt (440K) presentation quite nicely shows this idea of all tools and value-added components just talking a single protocol with a single configuration over a single link on slides 4-7.
What Layers of the OSI Model does TCF address?
In terms of the OSI Model, TCF addresses layers 5 - 7: reliable end-to-end transport is currently assumed to be available from underlying carriers. TCF cares for (5) Session Layer - Interhost communication; (6) Presentation Layer - Data representation and encryption through JSON; (7) Application Layer - TCF Services can be seen as Applications.
Determining on where TCF will be applied, it could also provide services for the (3) Network Layer - Path determination and logical addressing (IP) as well as the (4) Transport Layer - End-to-end connections and reliability (TCP) in the future, simply by implementing the TCF "Channel" abstraction with such lower level transport services as well.
The TCF Contribution
What is included in the TCF contribution?
In addition to the core Protocol and associated documentation, the initial contribution also consists of:
- Definition of some core services:
- Locator (for addressing)
- Remote File Access (File System Service)
- Remote Process List (System Monitor Service)
- Several Debug Services (Memory, Run Control, Registers, Stacktrace, Breakpoints).
- A reference agent implementation in plain C, tested on Linux, Windows and VxWorks
- Reference client implementations in Java and plain C (commandline testing client)
- Example tools using the services:
- Remote System Explorer (RSE) file service implementation, for remote file browsing
- RSE process service implementation, for remote process browsing
- Eclipse Debug Platform integration for debug demo
- DSDP-DD integration of core DD services.
- Example implementation of a value-add server (plain C)
- Example custom service add-on (plain C agent and Java client)
Where can I get TCF, and how do I get started?
Since there are no downloadable archives yet, you will need a Subversion client like TortoiseSVN or Eclipse to get the latest code out of the SVN Repository. Use File > Import > Team > Team Project Set with the following project sets:
Once in the workspace, look at the documentation rooted at docs/index.html . The TCF Getting Started document, which is also part of the documentation, shows how to build and set up a Workspace with TCF.
How is TCF licensed?
All TCF code is licensed under the Eclipse Public License (EPL) v1.0.
In addition to that, the plain C agent code is also licensed under the Eclipse Distribution License (EDL) v1.0, which is basically a very permissive BSD License in order to make it easier to redistribute the agent binaries linked into embedded devices such as mobile phones and the like with even less obligations than the EPL. To be clear, the agent is dual-licensed under both EPL and EDL which means that adopters can choose under what license they want to use it.
What other components does TCF depend on?
The core TCF protocol is just a specification, so it does not depend on anything -- the protocol can be implemented in any language within any environment.
The reference agent can currently be built on Linux, Windows and VxWorks and uses POSIX services only. Depending on what Services the agent should implement, an ELF reader (libelf) is required to perform debug line number translation. Currently, this is done on Linux only.
The Java core protocol client also does not have any particular dependencies.
The RSE, Platform Debug, and DSDP-DD example tools depend on the RSE, Platform Debug and DSDP-DD components respectively.
Where can I ask questions about TCF?
Write an E-Mail to the firstname.lastname@example.org mailing list.
How does TCF compare to ECF?
TCF defines the protocol, independent of APIs. ECF defines the APIs, independent of protocol. It's as simple as that. Or, to be more elaborate:
TCF is a "vertical" technology stack: it includes all components needed to communicate with embedded remote systems en-to end. This includes the plain C lightweight target agent, the TCF protocol specification at its core, the Java protocol API as well as 3 example clients.
ECF, on the other hand, is a "horizontal" technology: it deals with Eclipse Java APIs for a host of different protocols for any kind of communication needs. ECF wants to unify the usage patterns on the client side, such that protocols are exchangeable.
Therefore, the intersection (overlap) of TCF and ECF is on the Java client API, which makes up for about 20% of the TCF contribution. Here are some thoughts on that overlap:
- Both TCF and ECF have asynchronous APIs (request/callback and publish/subscribe, respectively).
- ECF allows clients to call into the APIs with any thread, and responds with callbacks on any thread.
- TCF translates all incoming calls to one well-defined thread and responds with callbacks on one well-defined thread. This may sometimes make it easier for clients and service providers to ensure data integrity.
- Both TCF and ECF have APIs for remote file transfer and discovery. The means for addressing are different, though: ECF Namespaces/IDs vs. simple IP address with implicit TCF protocol in TCF. Only TCF currently supports remote browsing (directory retrieval).
- TCF currently supports point-to-point communications only, whereas ECF supports one-to-many and many-to-many communications (The underlying metaphor is "Joining a communications container").
- ECF's charter to strive for generic interfaces makes it hard to prototype new communication protocols, or to drive features that one protocol has but another has not. The API is either the least common denominator of all protocols to be supported, or it has to provide mechanisms for querying remote capabilities such that features can be enabled/disabled - which makes using such interfaces harder for the client.
Summing up, it seems that while TCF is still incubating, it will be easier to stick with a Java API that's defined in TCF alone and develop the contribution under the DSDP/TM project; issues with dependencies and release cycles would otherwise make it unnecessarily complex to evolve the TCF protocol that's at the core of the contribution. At the same time, however, technology should be transferred between TCF and ECF as follows:
- TCF means for general API access, addressing and discovery should be reviewed and potentially aligned with the corresponding ECF mechanisms, to ensure that clients don't need to learn multiple programming paradigms for communications, and to ensure that TCF and ECF can eventually be combined to a single API.
- ECF APIs should be reviewed and/or extended to provide the features required by TCF, such that TCF fileshare and discovery implementations can eventually be implemented on top of ECF interfaces (thus TCF being just another ECF provider).
For more details, see also DSDP/TM/TCF - ECF Sync-up and Integration Meeting 4-Dec-2007
How can I contribute to this FAQ?
This is a collaborative FAQ. Feel free to correct anything you think may be wrong, not clearly answered, or has a Typo. Also feel free to add more questions and answers to this document.
The idea is that through collaborative editing, the document will eventually evolve. We welcome all contributions, anybody is invited to edit this Wiki page. Don't be shy about breaking anything - the page is being monitored and obvious mis-edits will be cleared by all the knowledgeable people monitoring the page.
How can I get notified of additions to that FAQ?
Log in to the Wiki. On your personal Preferences page, enable E-Mail notification. Then, click the watch tab of this page.