Shaping the Future of Efficient Computing

Mynatix’ technology is based on a naïve yet radical approach: Software itself should understand how to run best on the given hardware. To achieve this, LYOCS addresses a long-standing issue: detecting parallelism in code – and adapting it to automatically exploit the hardware’s (parallel) capabilities in a generic way.

Think of it as a manager who is instructing a team: If large projects are split up into smaller tasks and distributed among several people, the job can be completed faster. To achieve this, two things need to happen:

• The manager needs to communicate all relevant task-related information to the workers.
• The workers must then use this information to execute their respective tasks.

Until now the manager’s job in computing has had to be done manually by programmers during software development. A compiler is a computer program that translates human-readable source code into machine code that can be executed by a computing unit. Traditionally, compilers have had a restricted view on parallelism in code, and therefore limited capabilities to orchestrate workers and communication. During compilation, the compiler analyzes the code, divides it into basic blocks, maps them to available machine instructions, and optimizes execution for a specific computing unit.

Each block contains instructions on how to order it into a sequence of other software blocks to achieve the best results. These instructions are usually provided sequentially. Depending on the hardware architecture, it may be necessary to reorder the given instructions or to distribute them to different cores to optimally use the hardware’s computational power. Exploiting this information is called instruction-level parallelism (ILP) and provides the logical foundation for correctly handling control and data dependencies, guaranteeing that a program can be correctly written by the programmer and successfully executed.

Modern compiler frameworks efficiently optimize code for a target architecture with a single computing core. However, most of the modern computational challenges increasingly rely on platforms with multiple cores or special units that support parallel execution (e.g. GPUs). This is a matter of efficiency: if a problem can be broken down and solved by several computing units simultaneously, it can often be solved faster and more efficiently. This approach is known as parallel programming.

In systems with multiple computing units, programmers using state-of-the-art compilation technology are left to adapt their code manually to the specific architecture. This requires time, effort, and a certain degree of expertise. It starts with designing an algorithm and writing an appropriate code in a suitable language, while considering the hardware’s physical computing capabilities.

Although there are tools and libraries to support developers with this, fully automating the parallelization process remains challenging. The fact that parallelism often depends on runtime variables – whose meaning is only known when the code is running – further increases complexity.