We have defined and implemented a new kernel API that makes every
exported operation fully interruptible and restartable, thereby
appearing atomic to the user.  To achieve interruptibility, all possible
states in which a thread may become blocked for a ``long'' time are
completely representable as valid kernel API calls, without needing to
retain any kernel internal state. This API provides important
functionality. Since all kernel operations appear atomic, services such
as transparent checkpointing and process migration that need access to
the complete and consistent state of a process can be implemented by
ordinary user-mode processes. Atomic operations also enable applications
to provide reliability in a more straightforward manner. This API
also allows novel kernel implementation techniques and evaluation of
existing techniques, which we explore in this paper. Our new kernel's
single source implements either the ``process'' or the ``interrupt''
execution model on both uni- and multiprocessors, depending only on a
configuration option affecting a small amount of code.  Our kernel
structure avoids the major complexities of traditional implementations
of the interrupt model, neither requiring ad hoc saving of state, nor
limiting the operations (such as demand-paged memory) that can be
handled by the kernel.  Finally, our interrupt model configuration can
support the process model for selected components, with the attendant
flexibility benefits. We report preliminary measurements comparing
fully, partially and non-preemptible configurations of both process and
interrupt model implementations.  We find that the interrupt model has a
modest speed edge in some benchmarks, maximum latency varies nearly
three orders of magnitude, average latency varies by a factor of six,
and memory use favors the interrupt model as expected, but not by a
large amount.  We find that the overhead for restarting the most costly
kernel operation ranges from 2-8%.