Core Architecture:: Container Based

The major areas impacting performance and scalability under different application characteristics
are :- the core architecture, the concurrency model, the query implementation, the network model and
identity management.
Core Architecture:
The following presents three well known OODB architectural implementations. Each OODB
implementation provides degrees of distribution, parallel processing and remoting that are used to
create elaborate system level designs, but these are the core architectural types underpinning those
systems. Those are container based, page based and object based.
Container based:
The container-based architecture is a client centric design. It uses standard or proprietary NFS to
ship segments of disk around the network, called containers, to the clients which implement the
majority of the database functionality. The user application code is linked with the database client
libraries which provide caching of containers, query processing, transactions and object life cycle
management. All objects must reside inside a container and a container can hold many objects,
multiple containers can be used if the limit per container is reached.. In this architecture, application
developers must ensure container models are layered over application domain models to facilitate
access to objects within the database.
Fig-1:Container Based Architecture

Page based:
The page-based architecture is a client centric design which runs a server process to fulfill page
requests in a distributed virtual memory mapping model. It uses a server process to ship pages of disk
around the network which get address translated into the virtual memory space of the application,
where the majority of the database functionality is implemented. The user application code is linked
with the database client libraries which provide caching of pages, query processing, transactions,
object life cycle management. Special object placement strategies have to be implemented.
Fig-2:Page Based Architecture
Object based:
The object-based architecture is a balanced design with caching and behavior in both the application
and database server processes. The server process caches pages of disk and manages indexes,
locks, queries and transactions. The user application code is linked with the database client libraries
which provides object caching, local locking and object lifecycle management. No special object
placement strategies need to be implemented.
Fig-3:Object Based Architecture
The Concurrency Model:

The three core architectures have differing concurrency control models as described below. The
concurrency models solve the issue of transaction isolation and are closely tied with the network
behavioral characteristics. Each architecture has it's ways of relaxing locking for certain types of
applications where full ACID ( Atomic, Consistent, Isolated, Durable ) properties are not required. The
following is focused on behavior required for the consistency and isolation of proper database
transactions that are not relaxing the ACID properties. All implementations can cache locks locally at
the client across transaction boundaries to minimize unnecessary lock requests. However, updates
will always cause lock coordination and cache consistency operations. With container and page
based systems, object placement and locking are tightly coupled while in the object based systems
these issues are orthogonal. The different types of concurrency model are:
Container-Concurrency
Page-Concurrency
Object-Concurrency
The Network Model:

The three core architectures have differing network models affecting the bandwidth utilization and
performance in a distributed system design. Each network model is closely tied to the locking model
where upon obtaining a lock, the subsequent transfer of information occurs unless already cached
locally. The lowest level granularity of the transfer across the network is tied to the lowest granularity
of the lock. The different types of network model are:
Container-Network Model
Page-Network Model
Object-Network Model
The Query Implementation:

Object database implementations focus on their ability to navigate seamlessly between related
objects using the language constructs. The native support of a navigational access pattern is a key
advantage of OODBMS over the RDBMS complex join concept. Essentially, relationships are a static
part of the system rather than runtime calculated, which makes them inherently faster to use. For
each implementation, it is theoretically possible to define one master object which once retrieved
would provide navigational access to everything else in the database. However, as a matter of
practicality, application implementations are typically use case driven. It does not make sense to
needlessly bring in objects that are not relevant to the use case. Further, the scalability requirements
of large databases mandate efficient use of disk, network and memory. So, object databases provide
a means of querying to retrieve the first level objects of a use case and then allow subsequent
navigation from those starting objects. Again, it is not meant here to explain the detailed behaviour of
each query engine, but instead the fundamentals of the implementation. Specific details like the ability
to return id's, for lazy loading, instead of actual objects, etc are left out. The different types of query
implementation are:
Container-Query
Page-Query
Object-Query
Identity Management:
The core architectures all differ in their implementation approaches to identity management, yet they
fundamentally differ in two ways. Identity is either logical or physical in nature. Object databases use
identity in order to establish uniqueness and also to implement relationships. The difference in
implementation has profound implications on long term operational behaviour and flexibility. In
addition, the particulars of implementation for physical identity have an impact on data scalability for
systems requiring storage of multi-terabytes of information.
Unlike relational technology, a given OODB's architecture can exhibit orders of magnitude difference
in performance and scalability under a given set of application characteristics. Page and container
based architectures provide a good solution for applications with relatively fixed models, low or
medium concurrency and well segmented data. With object based architectures the concepts of:
object locking, object placement and object shipment are independent and provide the best solution
for high concurrency, growing and evolving applications and data.

Core Architecture:: Container Based

Uploaded by

Copyright:

Available Formats

Core Architecture:: Container Based

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Core Architecture:: Container Based

Uploaded by

Copyright:

Available Formats

The major areas impacting performance and scalability under different application characteristics

Fig-1:Container Based Architecture

Fig-2:Page Based Architecture

Fig-3:Object Based Architecture

The Concurrency Model:

The Network Model:

The Query Implementation:

You might also like