Ateji PX for Java - Integrating parallelism at the language level

[ hello(); || world(); ]

Multicore processors are already ubiquitous. Desktop PCs commonly use 4 cores, high-end servers typically 32 to 64 cores, and specialized processors for embedded systems already more than 200.

Multicore processors are here to stay, and you simply cannot afford to lag behind this revolution. But current programming paradigms make this a challenge.

As a software developer, you'll need very soon to become able to write and maintain parallel code. As a manager, you'll need to empower your developers with the means to write parallel code, without compromising your investments in source code, training, and existing development processes.

The problem with sequential languages

Most current approach for parallel programming take the form of additional libraries, that typically expose hardware-level concepts such as threads not well suited as a programming abstraction. Worse, the compiler only knows that your code is calling library methods, but it knows nothing about parallelism.

Traditional languages, such as C, C++, Java, C#, etc., are sequential in the sense that they require that statements be ordered, even when there is no reason to have them ordered. Consider for instance

a = a+1 ; b = b+1

versus

b = b+1 ; a = a+1

There is no reason to choose one order over the other, but a sequential language has no way to express this. Indeed, current approaches for parallel programming require that you

• first order the statements, as required by the sequential language,
• then that you add library code or preprocessor directives to express that this ordering should not be taken into account, so that they can be executed in parallel.

It is no surprise then that developers find parallel programming terribly difficult!

Simple and intuitive built-in parallel primitives

In contrast, a parallel language can compose statements without imposing any ordering on them. In Ateji^® PX, this is denoted by the || symbol:

a = a+1; || b = b+1; // increment a and b, in no particular order

Most mainstream programming languages do not allow the parallel composition of statements. Alternatives had to be developed, typically in the form of threading libraries that make hardware level or OS-level threading primitives accessible to the application developer. These ad-hoc approaches remain difficult to use because they still rely on a sequential language.

A parallel language like Ateji PX does not only make life easier for the programmer, it also enables the compiler to understand parallel programs and provide services such as:

• detection of bugs related to parallelism
• high-level code optimization
• automatic adaptation to different target architectures (multi-core, grid, cloud, etc.)

Ateji PX is implemented by source-to-source translation to the base language. This ensures compatibility with existing development tools and avoids technology lock-in (programmers can always switch back to the base language should they wish to do so). This also helps keeping the base language lean and standard.

Ateji PX also provides message-passing primitives at the language level:

• Send a message over a channel: chan ! value
• Receive a message from a channel: chan ? value

This enables the compiler to map distributed programs to various target architectures and write code that is independent of any given library.

Channels can be synchronous, efficiently implementing rendez-vous synchronization, or buffered. They can be mapped to I/O devices such as files and sockets.

In the example below, two parallel branches communicate through the channel chan:

// declare a channel visible by both branches, and instantiate it
Chan chan = new Chan();
[
   // send a value over the channel
   || chan ! "Hello";
   // receive a value from the channel, and print it
   || chan ? s; System.out.println(s);
]