This paper discussed the design and implementation
of a system that supports interrupt-transparent (nonblocking/
optimistic) synchronization of interrupt-driven
concurrent code. The presented approach assumes the
structuring of an interrupt-handling subsystem, e.g. a device
driver, into two parts: a prologue and an epilogue. The
prologue represents an asynchronously executing interrupt
handler. The epilogue represents a synchronously executing
prologue continuation allowed to execute critical sections of
an operating-system kernel. The connecting link between
both parts is implemented by a guard whose purpose is to
control the execution of so-called guarded sections. A serialization
of the execution of guarded sections is performed
by collecting delayed epilogues in a queue. In this setting,
the queue represents the single point whose implementation
has to be ensured to be interrupt safe.