The Prism Technology Platform, built on our Dynamic Insight Technology, is at the core of CriticalBlue's business. The deployment of this technology is central to ongoing customer relationships.

Our technology is based on dynamic binary level analysis which enables the dynamic instrumentation of compiled software running on most hardware platforms. This allows the capture of execution data down to the detail of individual instructions and data accesses. This opens up a range of analysis possibilities for our engineers to take advantage of.

Since the Prism Technology Platfom is so flexible, it can be deployed to the customer in many different forms, including tools, compilers, and runtime libraries. Some examples of this approach are given below.

 Binary Translation

Translation of the contents of a binary executable file from one instruction set to another supports the migration of software from one platform to another when there is no access to the original source code. The optimizing translation process also identifies potential code optimizations to improve performance on the new target including rescheduling and mapping to SIMD instructions where relevant.

 Software Security

Using binary analysis, the Prism Technology Platform can be deployed to provide a number of compile and runtime security enhancments to software. Code and data layouts can be statically and dynamically obfuscated and runtime memory contents for the process can be monitored for integrity. These approaches make it very difficult for an attacker to take control of or extract information from a process even if they achieved access to the rest of the system. The same underlying technology is at the heart of our Approov mobile API protection solution.


Several analysis capabilities from the Prism Technology Platform allow the customer to visualize memory access errors found by dynamic instrumentation of their software. These include buffer overrun, stack corruption, and data races on multicore platforms. Since the analysis is based upon a trace of runtime behavior, memory accesses leading up to an error can be tracked back through the source code within an IDE, making it a lot easier to find the original mistake in the code.

 Runtime Cache Optimization

In the case of complex, long running firmware applications, the memory access pattern gradually evolves over time, making static optimization difficult. This can result in degraded performance as data structures become large and fragmented, resulting in a high cache miss rate. A lightweight version of Prism forms the basis of a software library which detects data hotspots and remaps the data in memory at runtime to ensure good cache behavior.

 Adaptive Code Optimization

Many applications (Webkit, JIT code) feature a fragmented execution path through their instructions due to a high number of branches. This can lead to high instruction cache miss rates which are difficult to fix by simply refactoring the code.

Dynamic profiling is used at runtime to identify blocks of code which are frequently executed and then to rewrite the instruction memory so that these blocks are adjacent to one another. This improves the instruction cache hit rate, and since the process continues in the background over the lifetime of the application, the instruction layout is continually altered to track the changing execution pattern of the application code.

 Software Analysis

Leveraging the detailed trace capture features of our technology platform and our ability to analyze the resulting data in the context of the underlying hardware, the customer can analyze how well their software fits on a particular processor architecture based on dynamic instrumentation of the runtime behavior. This further supports processor architecture specific optimization by highlighting:

  • Poor use of data and instruction cache
  • Inefficient use of multiple cores by multi-threaded code
  • Sources of branch misprediction
  • Execution hotspots and computational pipeline stalls

These issues are presented in easy to use visualizations and tables, and in all cases link through to the relevant locations in the source code.