NOBLEProfessional Edition
is designed using the very latest
non-blocking techniques for achieving best
possible performance and scalability. The
actual performance in real applications
naturally depends on the specific run-time
environment and application design.
Therefore, NOBLE Professional Edition
contains several different versions of each
data structure so that the developer can
choose the best version for the specific
conditions.

Simple
non-blocking techniques have been used in a
large scope of commercial applications since
several years. These applications span from
business and trade applications, music and
synthesizer applications to even operating
system kernels. However, more advanced data
structures using non-blocking technology
haven't been available for developers until
now. With help from NOBLE Professional
Edition can developers now use
non-blocking versions of a large and rich
set of data structures based on
state-of-the-art algorithmic solutions.

BenchmarksHere follows some examples of stress-tests
on actual platforms, i.e. using the Core i7 920 processor from Intel containing
four processor cores that turn up as eight logical processors, thus
supporting real parallelism. As can be seen,
the various implementations of a certain
component have quite distinct performance
characteristics depending on internal as
well as environmental properties, thus
illustrating the usefulness of easily
supporting run-time selection of actual
implementation as offered by NOBLE Professional
Edition.

The above graph
shows an experiment with the different
versions of the Queue abstract data type
currently available in NOBLE Professional
Edition. The threads are accessing the
Queue with a medium load; between every
operation on the Queue, 500 floating-point arithmetic operations are
performed.

The above graph
shows an experiment where the threads are
accessing the Queue with a maximum load;
i.e. the threads are only performing
operations on the Queue.

The above graph
shows an experiment with several different
versions of the Dictionary (also known as
Map) abstract data
type, running with an average size of 1000
associated items. The threads are accessing the
Dictionary with a medium load; between
every operation on the Dictionary, 500 floating-point arithmetic
operations are performed.

The above graph
shows an experiment where the threads are
accessing the Dictionary with a maximum
load; i.e. the threads are only performing
operations on the Dictionary.

For more relevant
benchmarks showing the advantages in
performance for non-blocking techniques
compared to traditional techniques (e.g.
lock-based using mutexes or semaphores),
please see our white papers available in the
technical documents section. Please note
that besides increased parallelism,
non-blocking technology also offers other
very important features as increased
stability and termination guarantees, e.g.
threads can be killed even during an
operation on a data structure without
affecting the stability of the other threads.

Note that the
differences in performance and scalability
behavior between non-blocking
synchronization and traditional techniques
will be even more significant with
increasing number of cores, processors and parallelism.