Technology

How our products work

Learn how MatLogica products can turn your object-oriented code into data-oriented performance, achieving 6-100x speed ups for your analytics and computing sensitivities using ultra-fast AAD

Traditional methods to achieve performance

Developing accurate repetitive calculations such as Monte-Carlo simulations using traditional Object-Oriented languages requires use of multithreading and/or vectorisation. These are tricky to implement and can lead to intermittent issues and hard-to-maintain code.

Automatic Adjoint Differentiation (AAD) produces accurate sensitivities but is perceived as hard to implement and cannot be used to accelerate scenario analysis.

Traditional AAD tools use tape to record and replay calculations. MatLogica's AADC generates machine code (executable on a CPU) at runtime, and far exceeds performance of tape-based tools.

How is MatLogica Unique?

MatLogica’s easy-to-integrate JIT compiler converts user code (C++ or Python) into vectorized and multi-thread enabled, NUMA-aware machine code ('kernel') with the minimal number of operations theoretically necessary to complete the task.

By generating the kernel at runtime, we can take advantage of the information available during program execution and build in additional optimisations.

Our state-of-the-art code compression mechanism allows compression of the optimised machine code, leading to better cache utilization.

Accordingly, far fewer operations are loaded onto the CPU, extracting the maximal speed-up - something other libraries fail to achieve.

MatLogica’s AADC library additionally computes the reverse accumulation equations directly in the machine code (other libraries use tape), resulting in a far better performance than the alternative approaches.

Our tests show that AADC calculates both the original function and derivatives faster than the original code calculates the function alone, often by a factor of 6-100. This is achieved with minimal changes to the original code since Matlogica’s compiler does virtually all the work.

Our Integration Approach

MatLogica uses an unorthodox integration approach that delivers results in a few weeks while our competitors can take months or even years. The required code changes are minimal and can be performed by an experienced quant or developer with little to no additional training.

As the first integration step, you simply need to drop-in MatLogica AADC library into your project and migrate the 'double' type into our 'active double'.

Then, you will identify and mark the Inputs and Outputs for the target function and instruct our library to start recording. You only need to record a single sample to generate a binary kernel.

For subsequent samples, you will need to call our kernel instead of the original function.

Although we call our product a JIT-compiler, it doesn't have access to your source code. It can only access the information about overloaded variables and operations performed on them. In fact, it is a graph-compiler, not a compiler of your C++.

Along with straightforward integration, we offer debug tools that assist troubleshooting.