NOBLE
Professional Edition: Applications
Programmers Interface (API)
DOWNLOAD & READ
|
|
Products - NOBLE –
Contents
NOBLE
Professional Edition
contains a large number of components. Of
each component there are a number of
different versions (i.e., implementations), that each are based on
different technologies and approaches. The
technologies that are used are:
-
Lock-free synchronization.
This technology is non-blocking and means that no program
thread can block any other. Moreover, is
guaranteed that always at least one
program thread is making progress when
several program threads are working on
the same data. The technology has
a relatively low starting cost and
allows high scalability.
-
Wait-free
synchronization. This
technology is non-blocking and means that no program thread
can block any other. Moreover, is
guaranteed that all program threads that
have started an operation always will
finish in a finite time period.
The technology has a high starting cost
and allows high scalability with mostly
an increased cost in respect of memory
space.
- Lock-based
synchronization. This
technology means that program threads
can block others. The technology has a
low starting cost for a low number of
involved program threads, but a limited
scalability with increasing number of
program threads.
Parallel
versions of common abstract data types
 The components are
adopted for practical usage and have a
standardized interface in phase with common
and well established abstract data types and
data structures. As different applications
and environments have different
requirements, several implementations of
each component (sharing the same external
semantics) are available. The various
implementations are named according to their
special properties, e.g. lock-free,
wait-free, real-time, logarithmic time
complexity, dynamic structure, memory
consumption, etc. The following abstract data
types are included in
NOBLE Professional Edition:
|
Abstract Data
Type |
Implementations |
Operations |
|
Stack |
LF_B
LF_U
LB |
Push |
|
Pop |
|
Queue |
WF_SS
LF_DB
LF_DU
LF_SB
LB |
Enqueue |
|
Dequeue |
|
Deque
(Double-Ended Queue) |
LF_HB
LF_HU
LF_LB
LB |
PushLeft |
|
PushRight |
|
PopLeft |
|
PopRight |
|
Priority Queue |
LF_EB
LF_EU
LB_SD
LB_DD
LB_E |
Insert |
|
FindMin |
|
DeleteMin |
|
Dictionary (Map) |
LF_EB
LF_EU
LF_LB
LB_E |
Insert |
|
Update |
|
Find |
|
Delete |
|
List |
LF_SU
LF_DB
LF_DU
LB_S
LB_D |
InsertAfter |
|
InsertBefore |
|
Delete |
|
Next |
|
Previous |
|
Read |
|
First |
|
Last |
|
Snapshot |
WF_SS
WF_SM
WFR_SM
LB |
Update |
|
Scan |
Programming Example
|
C++ Syntax |
Description |
|
int
values[2]={1,2};
NBL::PQueue<int,int>
*pqueue; |
Globals |
|
pqueue = NBL::PQueue<int,int>::CreateLF_EB();
...spawn and run threads...
delete
pqueue; |
Main procedure |
|
pqueue->Insert(values+0,1); |
Thread x |
|
pqueue->Insert(values+1,2); |
Thread y |
|
int
*value = pqueue->DeleteMin();
if(value!=NULL)
{
...
} |
Thread z |
Moreover the
library contains various wait-fee and
lock-free implementations of atomic
operations on a single or a collection of
memory words, i.e. transactions. The supported
operations of the atomic Word component are
as follows:
|
Component Name |
Implementations |
Operations |
|
Word |
WF_B
WF_CASN
LF_LL |
Read |
|
Write |
|
Add |
|
Swap |
|
Op |
|
CAS |
|
CASN |
|
LL |
|
VL |
|
SC |
Sophisticated
memory management and configurability
In
addition, a number of lock-free memory
handlers are included that can be used in
combination with the abstract data types for
handling user-defined objects. This
component offers an efficient interface for
memory allocation and memory reclamation
using non-blocking technology. The
implementations offer a variety of
properties depending on the need to allocate
different block sizes or the strength of
guaranteeing the safety of accessing global
references concurrently. The supported
operations of the Memory component are as
follows:
|
Component Name |
Implementations |
Operations |
|
Memory |
LF SLB
LF SUU
LF MLB
LF WLB
LF CSLB
LF CSUU
LF CMLB
LF CWLB
LF HSLB
LF HSUU
LF HMLB
LF HWLB
WF SUU |
AllocBlock |
|
AllocClass |
|
AllocSize |
|
DeleteBlock |
|
DeRefLink |
|
CopyRef |
|
ReleaseRef |
|
StoreRef |
|
CASRef |
All components have an object-oriented design,
and can if so wishes be adjusted via a set
of parameters in order to fulfill special
and individual needs.
As has been
presented,
NOBLE Professional Edition contains a
rich set of components with a large number
of implementations using non-blocking
technology which widely surpasses (c.f. the
Intel Threading Building Blocks which
contains a fraction of the non-blocking
capability compared to NOBLE) what is
offered in other available packages.
For more
information, please see the description of
the application programmers interface (API)
which can be downloaded from our technical
documents pages.
NOBLE
Professional Edition is in first hand developed for the C/C++ program languages in
order to achieve highest performance, but
can easily be used also from other program
languages. An even more
detailed description of the contents in
NOBLE Professional Edition can be
obtained by contacting us through the form
at the contact page.
Note that we
can customize individual components to meet
special needs that are not fulfilled by our
packaged solutions. Please contact us with
your requests and needs, and we will give
you more details about possible deal offers
and licensing terms.
|
|
