Dimensional Data

C++11 allows the use of atomics in signal handlers, and with the advent of C++ 17 the signal handler feature was again improved. The std::atomic_flag is an atomic boolean type that is guaranteed to be lock-free and can be used in signal handlers. Moreover, the  header in C++ has an integer type std::sig_atomic_t that can be accessed as an atomic entity even in the presence of asynchronous interrupts made by signals. In this post, we explain how to use atomic_flag in C++. How to allow atomics use in C++ signal handlers? The header in C++ (or signal.h in C) has an an integer type std::sig_atomic_t that can be accessed as an atomic entity even in the presence of asynchronous interrupts made by signals. In this post, we explain how to allow atomics use in C++ signal handlers. Here is how we can use it:   #include   volatile sig_atomic_t flag = 0;   Is there a full example of how to use atomics in C++ signal handlers? Here is an example that has a signal handler and uses sig_atomic_t flag from 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39   #include #include   volatile sig_atomic_t flag = 0;   void handler(int signum) {    flag = 1 ; }   bool signal_check() {   if ( signal( SIGINT, handler) == SIG_ERR )   { return false;   }     if (flag) std::cout

C++ is very strong in every aspect of modern programming. Volatile types are used with the volatile keyword. It is a lesser known type qualifier that is important to read types or objects whose value can be modified at any time. The volatile keyword is useful in memory-mapped applications, generally these are from a hardware device, from a sensor, from an input device, or data from on an IoT. For example, an application reading dynamic data from the registers of a medical robot and decides what to do with that robot arm. In this post we will explain the volatile keyword in C++ and how can we use volatile type specifier. What is volatile keyword in C++? Volatile types are declared with the volatile keyword with a type declaration. Here’s how it is used.   volatile ;   We can use volatile on standard types, structs, unions. We can use them with pointers too. Here are some examples of how to use the volatile keyword in C++.   volatile int x;   volatile unsigned long int *p;   The volatile type specifier is used to change the variable whose values can be changed at any time and don’t have any constant value. The volatile qualifier is important to prevent the compiler from applying any optimizations on objects that can change in ways that cannot be determined by the compiler. Generally used in loops to read data, if you read those kinds of data without volatile types, the compiler and its optimizer can see the loop as useless. Your loop will never read the exact data in that time. For example, in this example:   unsigned int x = 255;   do {    // … }while( x == 255 );   compiler optimization covert this as below:   unsigned int x = 255;   do {   // … }while( true );   In other words, our loop becomes infinite by being true always even if the value of x is changed in some steps inside. To solve this, we can use volatile, thus we will keep reading data from x in do-while loop. Here is the example,   volatile unsigned int x = 255;   do {     // … }while( x == 255 );   If you want to keep reading x data from that address, you must use volatile specifier for the x type. This is why the volatile specifier is needed when developing embedded systems or device drivers. If we need to read or write a memory-mapped hardware device, we can use volatile type specifier on these kinds of data. Because data on that device register could change at any time, so we need to use volatile keyword to ensure that we read data on that time and such accesses aren’t optimized away by the compiler. Another need is some processors have floating point registers that have more than 64 bits of precision and if you need consistency then you can force each operation to go back to memory by using the volatile keyword.   Volatile specifier is also useful for some algorithms, such as Kahan summations, etc. Is there an example to use volatile keyword in C++? Assume that we have an address in our device or in a library of a driver, let’s set this address to a volatile […]

Modern C++ has many features to aid multi-thread programming that allow applications to be faster and more responsive. The C++11 standard offers the possibility of moving an exception from one thread to another. This type of movement is called propagating exceptions, exception propagation; also known as rethrow exception in multi-threading. To do that, some modifications have been made to the header in C++ and there is a nullable pointer-like type std::exception_ptr. In this post, we explain std::exception_ptr and how to use the rethrow exception method in modern C++. What are propagating exceptions (exception propagation) in modern C++? The C++11 standard offers a nullable pointer-like type std::exception_ptr. The exception_ptr is used to refer to an exception and manages an exception object that has been thrown and captured with std::current_exception(). Here is how we can use both:   std::exception_ptr e = std::current_exception();   In modern C++, a concurrency support library is designed to solve problems in multi-thread operations. This library includes built-in support for threads (std::thread), atomic operations (std::atomic), mutual exclusion (std::mutex), condition variables (std::condition_variable), and many other features. In addition to these useful features, std::exception_ptr is useful in exception handling between threads. They may be passed to another function, possibly to another thread function, so that the exception can be rethrown and handled in another thread with a catch clause. According to open-std, “An exception_ptr that refers to the currently handled exception or a copy of the currently handled exception, or a null exception_ptr if no exception is being handled. If the function needs to allocate memory and the attempt fails, it returns an exception_ptr that refers to an instance of bad_alloc. It is unspecified whether the return values of two successive calls to current_exception refer to the same exception.” The exception_ptr can be DefaultConstructible, CopyConstructible, Assignable and EqualityComparable. By default, it is constructed as a null pointer, doesn’t point to an exception, and operations from exception_ptr do not throw. Is there a simple example of how to use propagating exceptions in modern C++? Here is a simple example that outputs exceptions coming from a thread. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17   std::mutex m;   void throw_exception( std::exception_ptr e) { try { if (e) std::rethrow_exception(e); } catch(const std::exception& e) { m.lock(); std::cout

C++11 allows the use of atomics in signal handlers. In C++17 the signal handler feature is further improved. The std::atomic_flag is an atomic boolean type that is guaranteed to be lock-free and can be used in signal handlers. Moreover, the  header in C++ has an integer type std::sig_atomic_t that can be accessed as an atomic entity even in the presence of asynchronous interrupts made by signals. In this post, we explain how to use atomic_flag in C++. What is atomic_flag in C++? The std::atomic_flag is a flag in the atomics library which is known as an atomic boolean type. The std::atomic is guaranteed to be lock-and does not provide load or store operations. In addition, they provide synchronization and order constraints on the program execution. Here is the general syntax since C++11.   std::atomic_flag ;   Here is how we can declare it.   std::atomic_flag flag = ATOMIC_FLAG_INIT;   What are the features of atomic_flag in modern C++? The std::atomic_flag has useful features, these are as follows. The clear() feature is used to set flags to false atomically, in example we can use it with a memory_order as below,   flag.clear(std::memory_order_release);   test_and_set() tests the flag to true and obtains its previous value, in example we can use it with a memory_order in a while loop as we show in the example below:   while (flag.test_and_set(std::memory_order_acquire)) // acquire flag { }   The test() feature is new in C++20, returns the value of the flag atomically, like so:   while ( flag.test(std::memory_order_relaxed) ) // release flag { }   The wait() feature is new in C++20 and it blocks the thread until the atomic value changes and it is notified. Here is an example:   wait ( true, std::memory_order_relaxed);   in C++20, there are notify_one() and notify_all() features too. Note that, std::atomic_flag is a pretty low-level type – you can consider using atomic_bool instead. Also, you can use member functions with the set and the clear methods. You can also use higher level constructs, such as a std::mutex and std:: lock_guard. How to use atomic_flag in modern C++? Here is an atomic_flag C++ example. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34   #include #include #include #include #include   #include   std::atomic_flag flag = ATOMIC_FLAG_INIT;   std::stringstream stream;   void myf(int x) {   while ( flag.test_and_set() ) {}   stream

Since the C++11 standard, the Concurrency Support Library includes built-in support for threads (std::thread) with atomic operations (std::atomic). C++11 provides both weak and strong compare-and-exchange operations in multi-threading applications. Since C++11, weak compare and exchange are used in modern C++ standards such as C++14, C++17, C++20, and in other new standards. In this post, we explain weak compare and exchange with simple examples. What is weak compare and exchange in C++? The Weak Compare and Exchange template atomically compares the value pointed to by the atomic object with the value pointed to by expected. This feature comes with C++11 and is used in other modern C++ standards. and performs the following operations based on the comparison results: If the comparison result is true (bitwise-equal), the function replaces the value pointed to by the atomic object with the value desired. If the comparison result is false, the function updates the value in expected with the value pointed by the atomic object There are two most common syntaxes for the compare_exchange_weak, first,   bool compare_exchange_weak( T& expected, T desired) noexcept;   and in weak compare and exchange atomic operations, we can use std::compare_exchange_weak template with memory order types. Here is the syntax for the compare_exchange_weak with memory orders,   bool compare_exchange_weak( T& expected, T desired,                               std::memory_order success,                               std::memory_order failure ) noexcept;   here is how we can use it,   std::atomic x;   exchanged = x.compare_exchange_weak( expected, desired);   exchanged = x.compare_exchange_weak( expected, desired, std::memory_order_release, std::memory_order_relaxed);   Note that, providing both compare_exchange_strong and compare_exchange_weak allow us to decide whether we want the library to handle spurious failures (using compare_exchange_strong) or if we want to handle it in our own code (using compare_exchange_weak). The compare_exchange_strong needs extra overhead to retry in the case of failure. For details please see Load-link/store-conditional in Wikipedia. Is there a simple example of weak compare and exchange in C++? Here is a simple example about weak compare and exchange in C++. Let’s assume we have a thread function myf1() that ensures value is changed after a weak compare and exchange. This is how we can do this,   void myf1(int desired) { int expected = 1; bool exchanged;   do { exchanged = x.compare_exchange_weak( expected, desired ); std::cout