This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper    

Attend the next NDC conference near you: 
https://ndcconferences.com
https://ndctechtown.com/

Subscribe to our YouTube channel and learn every day:   
/     @NDC 

Follow our Social Media!

https://www.facebook.com/ndcconferences
https://twitter.com/NDC_Conferences
https://www.instagram.com/ndc_conferences/

#cplusplus 

Clang 20 introduced Function Effect Analysis (FEA), which enables real-time safety guarantees at compile-time. Mark your functions as non-throwing, non-allocating, or non-blocking — and have the compiler enforce it! For instance, a function marked non-allocating is not allowed to call malloc or new, and can only call other functions if they are also marked non-allocating (or if the compiler can deduce that they won't allocate).

In this talk, we will demonstrate function effect analysis and explain how it works. We will also see why it can be hard to enable FEA in the presence of third-party libraries, and what can be done about it.

At Squarehead, we've used FEA almost since its official release to refactor our soft real-time pipeline towards harder real-time. We will present our experience and lessons learned from this process, and the talk will be packed with useful real-life tips, tricks, and practices to set you up for success.

If time permits, we will also demonstrate the brand-new RealtimeSanitizer, the run-time companion to FEA.

After this talk, you'll know how and why to use Function Effect Analysis and RealtimeSanitizer and be aware of real-life tips, tricks, and practices for using them in your own projects.

NDC Conferences

Clang 20 introduces function effect analysis and real-time sanitizer to enforce real-time safety constraints at compile-time and runtime. The `[[clang::nonblocking]]` and `[[clang::nonallocating]]` attributes prevent functions from blocking on locks, allocating memory, or throwing exceptions. These constraints are transitive and support inference for templates and lambdas. Challenges include handling third-party code (requiring pragma-based opt-outs), type erasure with std::function (necessitating custom implementations), and retrofitting existing codebases. The approach works best with procedural code and requires compiler support (Clang 20+, Apple Clang 17+).

Real-time Safety — Guaranteed by the Compiler! - Anders Schau Knatten - NDC TechTown 2025