With a deep enough buffer, the above algorithm will always guarantee that the readers will not acquire corrupted data. However, when RMax is large or PW is small, NMax can get quite large and would require a large buffer space. This is undesirable, especially in embedded systems where memory is usually a scarce resource.
EMERALDS's state message algorithm [35] improves upon the NBW protocol. To limit memory usage, EMERALDS simply sets a static maximum buffer threshold for the state message. The reader tasks are divided into two groups, fast and slow readers. Tasks that have NMax values less than this maximum buffer threshold are classified as fast readers, while the others are classified as slow readers.
The fast readers execute according to the NBW protocol. Since these readers have small NMax values, they are both time- and space- efficient. For slow readers, EMERALDS provides a system call mechanism that (i) disables interrupts, (ii) copies the message from the shared buffer to the slow reader's local space on behalf of the reader, and (iii) re-enables interrupts. The overhead of this system call is quite high; however, according to the definition of slow readers, this call is invoked relatively infrequently, so it was claimed not to greatly impact the overall average-case execution time overheads.
As we will see in Section 4, the amount of overhead due to this system call is significant enough to make its average-case execution time much higher than the non-blocking algorithms. We would like to have the low execution overheads of the NBW protocol and the low memory usage achieved by the EMERALDS implementation, but without resorting to locks, disabled interrupts, or other synchronization-based concurrency control mechanisms. The following section details how to achieve this by transforming existing wait-free IPC mechanisms.