Implementing a Standard
It's important to understand the difference between a standard (such as the Multicore Association's Multicore Communications API, "MCAPI") and the implementation of that standard (such as PolyCore Software's "Poly-Messenger/MCAPI"). In order for software developers to take advantage of a standard, there must be an implementation of that standard that supports the architectures on which the application developer wishes their software to run.The Multicore Association developed the MCAPI standard, but commercial companies must adopt it and implement it within their RTOS and middleware products. Then, application developers can simply use it, and not have to program the various multicore devices on which they want their software to run. In one case, PolyCore Software has adopted MCAPI in its Poly-Messenger/MCAPI middleware, and Express Logic has provided RTOS support in its ThreadX RTOS. Together, this gives software application developers a simple API (MCAPI) which they can use to run anywhere that Poly-Messenger/MCAPI and ThreadX run.
Inter-core communication is a very hardware-specific operation. Any software that is written to perform such communication on a particular multicore chip must be modified to work with a different multicore chip. This "porting" is tedious, time-consuming, error-prone and technically challenging. MCAPI enables the application software developer to program to one API that is implemented by RTOS and middleware software across multiple multicore architectures. Those implementing MCAPI must do the "porting and tuning" to support MCAPI on various multicore architectures, but they must only do this once. The fruits of their one-time port then can be used by many developers who do not have to be concerned with the details of the multicore architecture on which their applications run, as long as they use MCAPI services through the MCAPI API.
In addition to "porting" MCAPI so that it runs on multiple multicore architectures, companies implementing MCAPI also will optimize their implementations so that their products run efficiently and provide applications with higher performance. Using an implementation with a standards-based communication API also makes it easier for the developer to try different mappings of an application across multiple cores for optimal performance.