JACC v1.0: High-productivity Performance Portability in the LLVM-compiled Julia Language

Modern supercomputers are becoming increasingly complex machines, packed with different types of processors that can solve problems at incredible speeds. For decades, scientists have relied on a few standard languages to tell these machines what to do, but as hardware evolves, writing code for these systems has become a difficult, specialized task. Researchers often find themselves forced to rewrite the same scientific programs multiple times, once for one type of computer chip and again for another, just to get the same result. This creates a bottleneck where the time spent translating code for different machines eats away at the time available for actual discovery. The goal for many in the field is to find a way to write a single set of instructions that works efficiently on any machine, whether it is a personal laptop or a massive national supercomputer, without needing to know the intricate details of every processor's design.

A team of researchers from Oak Ridge National Laboratory and other institutions has introduced a new tool called JACC, which aims to solve this problem for scientists using the Julia programming language. Julia is a language designed to be as easy to read as a mathematical formula while running as fast as the most efficient machine code. The new JACC software acts as a universal translator for this language, allowing scientists to write one version of their code that can run on the central processors of a computer or on the specialized graphics chips used for heavy calculations. The researchers found that this approach does not just make coding easier; it allows the software to run with nearly the same speed as code written specifically for each individual type of hardware. This means a scientist can develop a simulation on a laptop and then run the exact same program on a world-class supercomputer without changing a single line of the code.

The core of this achievement lies in how JACC handles the relationship between the scientist's work and the computer's hardware. In the past, moving a program from one type of processor to another often required a complete rewrite, much like translating a book from English to French and then to Japanese, with each translation risking the loss of nuance or speed. JACC removes the need for these separate translations. It provides a set of simple commands that tell the computer to perform a task, such as calculating values across a large grid of numbers, without specifying which specific processor should do the work. The software automatically detects whether the computer has a chip from NVIDIA, AMD, Intel, or Apple, and then directs the work to the most appropriate processor available. This flexibility allows researchers to use the powerful graphics cards found in modern laptops for interactive testing and then seamlessly switch to the massive arrays of processors in supercomputers for final, large-scale runs.

The researchers demonstrated the effectiveness of this system by testing it on a variety of real-world scientific problems. They applied the tool to simulations of fluid dynamics, which are used to model how air flows over wings or how water moves through pipes. In these tests, the software ran on different types of hardware with performance that matched or came very close to the specialized code written by experts for each specific machine. For example, when simulating the movement of fluids, the system achieved speeds on graphics chips that were within a few percent of the best possible performance, proving that the convenience of a single codebase does not come at the cost of speed. The team also showed that the system could handle complex tasks involving multiple processors working together on a single machine, a capability that is becoming essential as supercomputers pack more power into fewer physical units.

Beyond simple speed, the tool opens the door for more complex scientific explorations that were previously too difficult to manage. The researchers showed that JACC could be used to simulate quantum magnetic materials, a field that requires tracking the behavior of countless tiny particles. By using this new system, a calculation that previously took an hour to run on a single processor was reduced to just seconds when run on a graphics chip, all while using the same code. This kind of acceleration is vital for fields like quantum chemistry and nuclear physics, where scientists need to run thousands of variations of a simulation to understand how materials behave under different conditions. The ability to run these simulations on different hardware without rewriting the code means that scientists can focus more on the physics and less on the mechanics of programming.

The impact of this work extends to the future of how scientific software is built and maintained. The researchers noted that the system is designed to work alongside existing tools used by the scientific community, allowing for a gradual transition rather than a complete overhaul of current projects. This means that laboratories can adopt the new system piece by piece, testing it on specific parts of their code before committing to a full migration. The software also supports advanced features like shared memory, which allows different parts of a calculation to access data quickly, and asynchronous execution, which lets the computer start a new task before the previous one is fully finished. These features are critical for getting the most out of the latest supercomputers, which are designed to handle many tasks at once.

Looking ahead, the researchers see this technology as a foundation for even more advanced applications. They are exploring how the system could be used in the development of quantum computers, where the rules of physics are very different from the classical computers we use today. The ability to write code that is portable and efficient could help scientists design and test algorithms for these future machines long before the hardware is fully ready. Additionally, the system is being integrated with intelligent software that can automatically decide which processor should handle a specific task, further reducing the burden on the human programmer. This combination of ease of use and high performance suggests a future where the barrier between a scientist's idea and a running simulation is much lower than it is today.

The work presented in this paper represents a significant step forward in making high-performance computing accessible to a wider range of scientists. By providing a tool that bridges the gap between high-level programming and low-level hardware details, the researchers have created a path for more efficient and productive scientific discovery. The results show that it is possible to have both high productivity and high performance, two goals that have often been at odds in the past. As the world moves toward even more complex computing systems, tools like JACC will likely become essential for unlocking the full potential of these machines, allowing scientists to tackle problems that were previously too difficult to solve.