Ateji PX for Java - Integrating parallelism at the language level
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
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
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
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:
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:
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
We just completed an evaluation of Ateji's product, and it does everything it promises… this is a very smart idea
Ateji PX allows quicker and easier Java parallel programming without several of the pain-points of multithreading coming in the way
Ateji PX is a dream for Java™ developers, enabling all kinds of applications to take better advantage of NVIDIA’s multicore processors.
Thank you for this brilliant piece of engineering