IN THE MIDDLE OF SOFTWARE SAFETY LIES OPPORTUNITY

The timeline of guidelines published by the European Union[1], the UK government[2] and USA government[3] reveals an increasing focus on software safety. Such recommendations and guidelines are usually the prelude to enforceable regulations. In the last decade, similar regulations, such as the European General Data Protection Regulation (GDPR) and the Market in Financial Instruments Directive II (MIFID II), not only monopolised internal software development efforts, but also dramatically increased the demand for consulting services to implement regulatory changes within regulatory timeframes. Data Intellect’s data driven strategy is to inform its clients of potential challenges ahead, clarify the nature of those challenges, address them and eventually turn them into opportunities.

Safety critical systems and memory unsafe languages are not mutually exclusive. In the automotive industry, AUTOSAR recognises that the performance offered by C++ should not come at the detriment of software and functional safety. MISRA shares the same vision for C/C++ software safety by restricting those language to a subset of safe usages and programming constructs. The C++ Core Guidelines aims to improve software safety by a combination of:

• Promoting a high quality programming style, especially when dealing with memory and initialisation, thus improving memory safety.
• A supporting software library enforcing adherence to its rules.

Herb Sutter is notably working on a safer flavour of C++, C++ 2.

Sofware safety can be significantly improved by leveraging existing tools

• Linters do provide warnings on coding style and safety.
• Static analyzers such as Cppcheck can detect bugs and dangerous code before it is even built.
• Sanitizers do instrument code for runtime bug detection, but can be only used during testing time due to the runtime overhead.

Knowledge from safety critical industries can be leveraged in the financial industry

Safety critical industries such as Automotive or Plane industry already have very strong software development safety rules.

Strive for compile time checks, rather than runtime checks

C++ has a competitive advantage when it comes to type safety. On the top of strong typing, C++20 Constraints and concepts break compilation on invalid operations attempted on data structures and functions under their control.

Whenever possible:

Use static memory allocation instead of dynamic memory allocation

Allocating static and fixed size chunks of memory at startup seems to take us back to the Fortran world. But is it better to deal with memory allocation failure at startup, or during execution[5]? In the same way that business units are allocated fixed -and limited- resources, why can’t a program be allocated all the resources it needs at startup?

Embedded real-time systems – that only moderately enjoy undefined runtime behaviour tend to avoid dynamic memory allocation due to the indeterministic response time it involves, a concern shared in low latency trading.

Replace dynamic collections with fixed size collections

Fixed size circular buffers are typically used in the gaming industry[6] for they provide higher performance than dynamic collections. Fixed size collections such as std::array forbid the use of expensive memory resizing operations such those offered by std::vector.

Replace pointer-based collections with flat collections

Cache friendly flat collections, such as those in the latest <flat_map> and <flat_set> adapters, represent node links with contiguous array elements instead of pointers-based links. Thus, they can leverage hardware cache associativity and prefetching. By contrast, standard collections such as std::map and std::set, represent node neighbours as pointers. This implies that they have no control on the proximity of those neighbors, which in turns disables hardware caches strategies.

Chapter 12 of Introduction to Algorithms highlights how to use one dimensional or multidimensional arrays to represent linked lists.

Data intellect technical proposition boils down to design guidelines enabling software safety and high performance, such as:

• Replacing dynamic memory allocation with static memory allocation whenever possible. When that is not possible, reuse existing dynamically allocated buffers and increase their size to the high watermark, as to minimise the runtime cost of dynamic memory allocation.
• Use flat/cache friendly memory data structures caches rather than pointer-based ones, as to leverage hardware optimisation (e.g. level 1/2/3 caches, prefetching…).