Intuitive

Fast

Reliable

Intuitive, Fast, Reliable.

Intuitive

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...

Distribution

The distributor object consumes a single event on its input connection and produces a copy on each of its output connections.

Collection

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.

Multiplexing

The multiplexer object propagates an event from any one of its input connections to its output connection.

Arbitrary Composability

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:

Method Object

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.

Fast

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.

CORE Benchmarks

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)

Reliable

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
• High-throughput

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.