Technology
Barriers to Multicore Programming
Parallel programming can be difficult. In fact, it has become the number one barrier to exploiting the performance benefits of multicore architectures. Using an innovative new technology, TMT has developed multicore programming solutions that overcome the most common barriers facing application developers trying to program parallel systems.
Barrier #1) Developing parallel code:
Using traditional software development methodologies, originally developed for sequential programming, there are three well defined steps required for parallel programming.
- Identify parallelisms: Analyze the problem to identify tasks that can execute in parallel.
- Expose parallelisms: Restructure a problem so tasks can be effectively exploited. This often requires finding the dependencies between tasks and organizing the source code so they can be effectively managed.
- Express parallelisms: Express the parallel algorithm in source code using a parallel programming notation.
The expertise, time and effort required to develop parallel programs using these traditional techniques can be prohibitive.
TMT Solution: Introduce a simple, declarative language for expressing algorithm intent - without the need to specify parallelisms or implementation structure - and employ an innovative automatic compiler that automatically identifies and exposes and expresses the parallelisms. The SequenceL™ compiler enables application developers to quickly generate optimized, threaded application code from simple algorithmic descriptions of the code functionality.
Barrier #2) Synchronizing the multicore system:
It is not enough to simply understand how an application can be split into parallel threads. The second barrier to parallel programming is the need for the application developer to understand how the multicore system will process the multiple threads. Listed here are just some of the details of the computing system that the application developer must understand in great detail in order to optimize the application.
- Load balancing: Though the target system might have multiple cores, some of those cores will be engaged by the operating system or by other critical applications. The developer must understand how to distribute the application across available resources, and how to keep all the processors fed with work at the right times.
- Memory access: As processes are distributed, the data accesses may also be distributed across processors. The user must take into account the available memory and how the processors communicate with memory to avoid processors sitting idle waiting for data, creating memory conflicts, or worse, corrupting data.
- Processor communications: The application developers must become experts in multicore bus protocols to ensure the inter-processor communications don't create bottlenecks that slow down the operation of the application, making the parallel code slower than the sequential implementation.
In order to optimize an application for parallel processing, the application developer must understand the target multicore system in great detail, manipulating processes that are normally taken for granted in sequential programming.
TMT Solution: The SequenceL™ compiler averts the need for users to become experts in multicore processor design. The technology includes an optimization layer that distributes the application across the available processors, and optimizes memory accesses and communications for the parallel implementation.
Barrier #3) Transporting the multicore application:
Multicore systems today are evolving quickly from simple dual core processor chips to complex computing systems delivering 8, 12, 16, 24, 32, 64, and many more processor cores. These architectures each have unique characteristics that developers must exploit to optimize application performance. As a result, code that is optimized for a quad-core processor on one OS, may not perform well on a different system or with a different OS.
Using traditionally sequential programming methodologies, the effort required to generate parallel code, and then to optimize that code will often result in an application that only works for one computing system. And unfortunately, using sequential coding techniques, the amount of effort to port to another system may still be prohibitively large.
TMT Solution: The SequenceL™ compiler uses code that is implementation neutral. The compiler is used to optimize the code for the multicore target. So using TMT technology, applications can be ported to new multicore processors, new machine configurations and new operating systems without incurring the costs, time and effort associated with traditional programming methodologies.
- SequenceL™ - Multicore compiler extracts parallelisms from compact algorithmic programming language descriptions and generates C++ code for multicore systems
- ThreadedS™ - Software acceleration service, provides the fastest path to performance optimized multi-core applications