Are Exceptions in C++ really slow

by

The main model used today for exceptions (Itanium ABI, VC++ 64 bits) is the Zero-Cost model exceptions.

The idea is that instead of losing time by setting up a guard and explicitly checking for the presence of exceptions everywhere, the compiler generates a side table that maps any point that may throw an exception (Program Counter) to the a list of handlers. When an exception is thrown, this list is consulted to pick the right handler (if any) and stack is unwound.

Compared to the typical if (error) strategy:

  • the Zero-Cost model, as the name implies, is free when no exceptions occur
  • it costs around 10x/20x an if when an exception does occur

The cost, however, is not trivial to measure:

  • The side-table is generally cold, and thus fetching it from memory takes a long time
  • Determining the right handler involves RTTI: many RTTI descriptors to fetch, scattered around memory, and complex operations to run (basically a dynamic_cast test for each handler)

So, mostly cache misses, and thus not trivial compared to pure CPU code.

Note: for more details, read the TR18015 report, chapter 5.4 Exception Handling (pdf)

So, yes, exceptions are slow on the exceptional path, but they are otherwise quicker than explicit checks (if strategy) in general.

Note: Andrei Alexandrescu seems to question this “quicker”. I personally have seen things swing both ways, some programs being faster with exceptions and others being faster with branches, so there indeed seems to be a loss of optimizability in certain conditions.

Does it matter ?

I would claim it does not. A program should be written with readability in mind, not performance (at least, not as a first criterion). Exceptions are to be used when one expects that the caller cannot or will not wish to handle the failure on the spot, and pass it up the stack. Bonus: in C++11 exceptions can be marshalled between threads using the Standard Library.

This is subtle though, I claim that map::find should not throw but I am fine with map::find returning a checked_ptr which throws if an attempt to dereference it fails because it’s null: in the latter case, as in the case of the class that Alexandrescu introduced, the caller chooses between explicit check and relying on exceptions. Empowering the caller without giving him more responsibility is usually a sign of good design.

More Related Contents:

  1. Vector of const objects giving compile error
  2. Default, value and zero initialization mess
  3. C++ 11: conversion const int* to int* using unordered_set::push
  4. cout
  5. A confusing detail about the Most Vexing Parse
  6. Two different values at the same memory address
  7. What are the differences between struct and class in C++?
  8. constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right?
  9. Is floating-point == ever OK?
  10. How do I write a range pipeline that uses temporary containers?
  11. Does true equal to 1 and false equal to 0? [duplicate]
  12. QtCore.QObject.connect in a loop only affects the last instance
  13. Parsing Command Line Arguments in C++? [closed]
  14. Are parent class constructors called before initializing variables?
  15. Can a cast operator be explicit?
  16. How do the stream manipulators work?
  17. Can i use nested loops with vectors in cpp?
  18. How to use boost preprocessor to generate accessors?
  19. Function clrscr in C and C++
  20. C++ Structure Initialization [duplicate]
  21. How can an incomplete type be used as a template parameter to vector here?
  22. c++ sizeof(array) return twice the array’s declared length
  23. Undefined behavior causing time travel
  24. When Does Move Constructor get called?
  25. How do I use the MinGW gdb debugger to debug a C++ program in Windows?
  26. Why must I put a semicolon at the end of class declaration in C++?
  27. sprintf for unsigned _int64
  28. Unable to read frames from VideoCapture from secondary webcam with OpenCV
  29. If a 32-bit integer overflows, can we use a 40-bit structure instead of a 64-bit long one?
  30. Wrapping FILE* with custom std::ostream

Leave a Comment