recent years, that is in past 5 years Linux has seen significant growth as a server
operating system and has been successfully deployed as an enterprise for Web,
file and print servicing. With the advent of Kernel Version 2.4, Linux has seen
a tremendous boost in scalability and robustness which further makes it feasible
to deploy even more demanding enterprise applications such as high end database,
business intelligence software ,application servers, etc. As a result, whole enterprise
business suites and middleware such as SAP, Websphere, Oracle, etc., are now available
For these enterprise applications
to run efficiently on Linux, or on any other operating system, the OS must provide
the proper abstractions and services. Usually these enterprise applications and
applications suites or software are increasingly built as multi process / multithreaded
applications. These application suites are often a collection of multiple independent
subsystems. Despite functional variations between these applications often they
require to communicate with each other and also sometimes they need to share a
common state. Examples of this are database systems, which typically maintain
shared I/O buffers in user space.
such shared state must be properly synchronized. Allowing multiple processes to
access the same resources in a time sliced manner or potentially consecutively
in the case of multiprocessor systems can cause many problems. This is due to
the need to maintain data consistency, maintain true temporal dependencies and
to ensure that each thread will properly release the resource as required when
it has completed its action. Synchronization can be established through locks.
There are mainly two types of locks: - Exclusive locks and shared locks. Exclusive
locks are those which allows only a single user to access the protected entity,
while shared locks are those which implements the multiple reader - single writer
semantics. Synchronization implies a shared state, indicating that a particular
resource is available or busy, and a means to wait for its availability. The latter
one can either be accomplished through busy-waiting or through an explicit / implicit
call to the scheduler.
CONCURRENCY IN LINUX
As different processes interact with each
other they may often need to access and modify shared section of code, memory
locations and data. The section of code belonging to a process or thread which
manipulates a variable which is also being manipulated by another process or thread
is commonly called critical section. Proper synchronization problems usually serialize
the access over critical section. Processes operate within their own virtual address
space and are protected by the operating system from interference by other processes.
By default a user process cannot communicate with another process unless it makes
use of secure, kernel managed mechanisms. There are many times when processes
will need to share common resources or synchronize their actions. One possibility
is to use threads, which by definition can share memory within a process.
option is not always possible (or wise) due to the many disadvantages which can
be experienced with threads. Methods of passing messages or data between processes
are therefore required. In traditional UNIX systems the basic mechanisms for synchronization
were System V IPC (inter process communication) such as semaphores, msgqueues,
sockets and the file locking mechanisms such as flock() and fcntl() functions.
Message queues (msgqueues) consist of a linked list within the kernel's addressing
space. Messages are added to the queue sequentially and may be retrieved from
the queue in several different ways. Semaphores are counters used to control access
to shared resources by multiple processes.
You might also like the below seminar topics
Palm Vein Technology
Parallel Virtual Machine
Pivot Vector Space Approach in Audio-Video Mixing