Intuitive, Fast, Reliable.
BLUEPRINT provides you with the tools you need to easily express and verify the concurrent behavior of your applications and a runtime that ensures the highest levels of performance and reliability across any number of cores...
" Asymmetric multi-core computing (...) will extend the capability of multi-core processors (...), giving rise to a significant set of software challenges and opportunities. "
Preparing for the Second Stage of Multi-Core Hardware,
More from the experts...
Intuitive Graphical Symbolism
BLUEPRINT's graphical symbolism provides a set of simple event operators that allow you to express the concurrent behavior of your application intuitively.
The three most fundamental operations are distribution, collection and multiplexing...
The distributor object consumes a single event on its input connection and produces a copy on each of its output connections.
The collector object collects an event from each of its input connections and when they have all arrived it produces a compound event on its output connection.
The multiplexer object propagates an event from any one of its input connections to its output connection.
All operators can be composed in any order. So for example, the compound event produced by a collector can be multiplexed with other events and that multiplexed event can be distributed to multiple consumers (as shown in the above diagram). There is no limit to this composability.
Seamless Sequential Code Integration
Any event can be used to trigger a portion of sequential code by connecting to the trigger face of a method object as shown in the following example:
The method object generates a stub handler function into which any sequential code can be placed.
Fully Encapsulated Components
The following diagram shows a BLUEPRINT component that encapsulates a Fast Fourier Transform (FFT) algorithm. It consists of two parts:
- A definition containing the encapsulated circuitry and its external connection points called pins (top)
- A prototype specifying the structure of the events that the circuit provides or must consume (bottom)
A BLUEPRINT Component Encapsulating an FFT
The hexagonal object is a transient store, which holds references to data records and provides events with read-only, write-only or read-write permissions as required.
Having created a component, it can be instantiated and connected as shown in the following diagram:
An Instance of the FFT Component
The objects that are connected to the circuit instance must conform to its prototype or BLUEPRINT will raise a validation error. Circuits can be connected to objects, other circuits or to pins provided that the prototypes are consistent.
BLUEPRINT's ability to break applications into strongly prototyped sub-circuits and re-usable components makes it easy to manage large, complex projects.
Localized Concurrency Description
BLUEPRINT's symbolic language is concerned only with programming the concurrency of an application. This means that all of your concurrency-related 'code' is contained in a localized graphical description, which has the following advantages:
- Easier to browse
- Easier to debug deadlocks, race conditions, etc.
- Easier to maintain
Full Visual Studio 2005 & 2008 Integration
Full Studio Integration
Can Run In One Thread For Easier Debugging
During development it is often desirable to run your application in a single thread to avoid the confusion of context switching between multiple threads.
BLUEPRINT's CORE runtime allows you to specify the maximum number of worker threads that the process is allowed to create.
High Performance Runtime
BLUEPRINT's CORE runtime employs unique algorithms that enable high-performance, data and task parallel applications through:
- Excellent load balancing
- Near theoretical maximum scalability
- Very low overhead
- Minimal resource contention
- No unnecessary data movement
- No unnecessary thread proliferation
Multi-Core processors can offer you huge potential performance scale-up. BLUEPRINT provides the tools to realize these potential gains without significant extra development effort.
Alternative parallel programming solutions tend to focus on data-parallel problems. However, even 'embarrassingly-parallel' problems such as 'parallel-for' loops can introduce inefficiencies due to runtime overheads and imperfect load balance.
(Click to enlarge...)
The diagrams above show the relative performance of the TPL and CORE runtimes for two cases.
- A very simple deterministic data-parallel case (left)
- A more realistic problem where the calculation time depends on the data (right)
The complete benchmark report will be available soon.
Real World Apps - Not Just Data Parallel
CORE performs extremely well when unrolling simple for-loops. However, its real edge becomes apparent when tackling general day to day problems such as:
- GUI offloading to improve responsiveness (no more hour-glass)
- Reducing latency in the financial sector (one millisecond in latency saved can equate to $100M+ in improved annual revenue)
- Providing optimal fidelity (video games that improve detail after minimum frame rate is achieved)
Easy To Analyze BLUEPRINT Applications For Concurrent Bugs
BLUEPRINT's symbolism localizes the concurrent aspect of your application so that you can see it all in one place rather than having to search through many files for particular keywords and build up a picture in your mind. This makes the discovery and resolution of common concurrency bugs (dead-locks, race conditions etc.) much easier.
The following example shows a very simple dead-lock scenario in which a collector is requesting both a read and write buffer from the same store:
Simple Dead-Lock Scenario
If the number of buffers in 'MyStore' is set to 1 then the collection sequence will never be satisfied as only one buffer can be collected.
Mature Runtime Library
BLUEPRINTís CORE runtime has been in continuous development and use since 1993 and has been subjected to the most demanding production environment. Typical applications have been:
- Mission critical
- Hundreds of thousands of lines of code
- Hard realtime constrained
For example, the CORE runtime was used for the UK's Surface Ship Torpedo Defense system (SSTD) and the Watchkeeper Unmanned Aerial Vehicle (UAV) projects (See Solutions). Both of these systems are mission critical and 24-7 reliability is a crucial requirement.
Build Fully Encapsulated Multi-Core Components
As described above, BLUEPRINT enables the creation of strongly prototyped components. The ability to encapsulate code in re-usable components is a key aspect of improving reliability as it provides an incentive to invest in and refine those components over time.