IPC Interview Prepration

kuldeep_ecb

Question:- Explain difference between IPC

Answer: Ipc mechanisms are mianly 5 types

1.pipes: it is related data only send from one pipe output is giving to another pipe input to share resourse pipe are used

drawback: it is only related process only communicated

2.message queues:message queues are unrelated process are also communicate with message queues

drawback: user don't know which process currently works

3. shared memory:memory shared in distributed systems some memory wants to share some files that time it is use full
4. semaphores
semaphore is integer type and in semaphore resources give coding like negative value means process are wants to use particular resource waiting only
and 0 means no process is waiting
and 1 means one resource is free

5. sockets: sockets also IPC it is communicate clients and server with socket system calls connection oriented and connection less also.

kuldeep_ecb

What do you mean by “unicast” and “multicast” IPC?
Ans: In distributed computing, two or more processes engage in IPC using a protocol agreed upon by the processes. A process may be a sender at some points during a protocol, a receiver at other points.

When communication is from one process to a single other process, the IPC is said to be a unicast, e.g., Socket communication.

When communication is from one process to a group of processes, the IPC is said to be a multicast, e.g., Publish/Subscribe Message model.

kuldeep_ecb

Differentiate between synchronous and asynchronous communication?
Ans:The IPC operations may provide the synchronization necessary using a blocking operation issued by a process will block further processing of the process until the operation is fulfilled.

Alternatively, IPC operations may be asynchronous or nonblocking.An asynchronous operation issued by a process will not block further processing of the process. Instead, the process is free to proceed with its processing, and may optionally be notified by the system when the operation is fulfilled.

kuldeep_ecb

Explain deadlocks and timeout.
Ans: Blocking operations issued in the wrong sequence can cause deadlock. Timeout can be used to detect deadlocks.Connect and receive operations can result in indefinite blocking.For example, a blocking connect request can result in the requesting process to be suspended indefinitely if the connection is unfulfilled or cannot be fulfilled, perhaps as a result of a breakdown in the network .It is generally unacceptable for a requesting process to “hang” indefinitely. Indefinite blocking can be avoided by using timeout.

kuldeep_ecb

Are function callback and inter-process communication same?
Ans: Function callback is passing the address (or some other identifier) of a function to another function so that it can call back for some reason.

IPC, on the other hand, is a means for processes to communicate with each other, such as shared memory, pipes, semaphores and so on.

Some IPC mechanisms may use callbacks but it’s by no means necessary. For example, sockets don’t use callbacks, they simply allow a user to call read and write.

kuldeep_ecb

Suppose we have three threads T1, T2 and T3 which perform sequentially one after another is their any benefit of using thread over here rather than having a single process?

here T1, T2 and T3 as a thread consumes less memory and more speed but as a process it consumes more memory.

Example:

Multiple threads can be run within a single memory allocations.

but process needs seperate memory allocations for each process.

kuldeep_ecb

What is the use of thread over process?

Thread is an executable entity but it is bound to its parent
process.
now there are two types of threads.
1. user space threads and
2. kernel thread
now the kernel threads are actually known as light weight
processes.

why light weight????
>>>> as it's context switching times is lesser than all other process.

now why the context switching time is less????
>>>>> as process have there own process address space and maintains many more things like userID, ProcessID, groupID, number of files opened, reisters and blah, blah whereas thread shares it's parent process's address space and mainly contains three things like own stack, registers and thread related data.
so more things to swap need more time that's why thread's context switching time is less compared to that of a process.

now the answer,
use of thread: thread are used to provide multi-programming environment.
ok, now u ppl would think that, it can also be done creating new processes (using fork())
yes we can, but as i told earlier that the context switch time for threads are very less.moreover the inter-thread communication is more easier than inter-process communication as all threads of a single process uses the same address space.

kuldeep_ecb

What are the Advantages and disadvantages of script vs compiled program?

While scripts have the advantages of
1) flexibility to change the of script
2) and being more portable.

Compiled executables have the advantages of
1) less memory footprint
2) less execution time.

kuldeep_ecb

What is YUM?

YUM stands for Yellow dog Updater, Modified because it is based on YUP, the Yellow dog Updater. Where does the name Yellow dog come from? Yellow Dog is a version of Linux for the Power Architecture hardware and is RPM-based, just like Red Hat Enterprise Linux and Fedora. YUP, and later YUM, were written by the Linux community as a way to maintain an RPM-based system

kuldeep_ecb

What is the difference between ext2 and ext3 file systems?

The ext3 file system is an enhanced version of the ext2 file system.
The most important difference between Ext2 and Ext3 is that Ext3 supports journaling.
After an unexpected power failure or system crash (also called an unclean system shutdown), each mounted ext2 file system on the machine must be checked for consistency by the e2fsck program. This is a time-consuming process and during this time, any data on the volumes is unreachable.
The journaling provided by the ext3 file system means that this sort of file system check is no longer necessary after an unclean system shutdown. The only time a consistency check occurs using ext3 is in certain rare hardware failure cases, such as hard drive failures. The time to recover an ext3 file system after an unclean system shutdown does not depend on the size of the file system or the number of files. Rather, it depends on the size of the journal used to maintain consistency. The default journal size takes almost a second to recover, depending on the speed of the hardware.

kuldeep_ecb

Differentiate between synchronous and asynchronous communication?
Ans:The IPC operations may provide the synchronization necessary using a blocking operation issued by a process will block further processing of the process until the operation is fulfilled.

Alternatively, IPC operations may be asynchronous or nonblocking.An asynchronous operation issued by a process will not block further processing of the process. Instead, the process is free to proceed with its processing, and may optionally be notified by the system when the operation is fulfilled.

kuldeep_ecb

Explain deadlocks and timeout.
Ans: Blocking operations issued in the wrong sequence can cause deadlock. Timeout can be used to detect deadlocks.Connect and receive operations can result in indefinite blocking.For example, a blocking connect request can result in the requesting process to be suspended indefinitely if the connection is unfulfilled or cannot be fulfilled, perhaps as a result of a breakdown in the network .It is generally unacceptable for a requesting process to “hang” indefinitely. Indefinite blocking can be avoided by using timeout.

kuldeep_ecb

Are function callback and inter-process communication same?
Ans: Function callback is passing the address (or some other identifier) of a function to another function so that it can call back for some reason.

IPC, on the other hand, is a means for processes to communicate with each other, such as shared memory, pipes, semaphores and so on.

Some IPC mechanisms may use callbacks but it’s by no means necessary. For example, sockets don’t use callbacks, they simply allow a user to call read and write.

kuldeep_ecb

Mutex vs Semaphore

What are the differences between Mutex vs Semaphore? When to use mutex and when to use semaphore?

Concrete understanding of Operating System concepts is required to design/develop smart applications. Our objective is to educate the reader on these concepts and learn from other expert geeks.

As per operating system terminology, mutex and semaphore are kernel resources that provide synchronization services (also called as synchronization primitives). Why do we need such synchronization primitives? Won’t be only one sufficient? To answer these questions, we need to understand few keywords. Please read the posts on atomicity and critical section. We will illustrate with examples to understand these concepts well, rather than following usual OS textual description.

The producer-consumer problem:

Note that the content is generalized explanation. Practical details vary with implementation.

Consider the standard producer-consumer problem. Assume, we have a buffer of 4096 byte length. A producer thread collects the data and writes it to the buffer. A consumer thread processes the collected data from the buffer. Objective is, both the threads should not run at the same time.

Using Mutex:

A mutex provides mutual exclusion, either producer or consumer can have the key (mutex) and proceed with their work. As long as the buffer is filled by producer, the consumer needs to wait, and vice versa.

At any point of time, only one thread can work with the entire buffer. The concept can be generalized using semaphore.

Using Semaphore:

A semaphore is a generalized mutex. In lieu of single buffer, we can split the 4 KB buffer into four 1 KB buffers (identical resources). A semaphore can be associated with these four buffers. The consumer and producer can work on different buffers at the same time.

Strictly speaking, a mutex is locking mechanism used to synchronize access to a resource. Only one task (can be a thread or process based on OS abstraction) can acquire the mutex. It means there is ownership associated with mutex, and only the owner can release the lock (mutex).

Semaphore is signaling mechanism (“I am done, you can carry on” kind of signal). For example, if you are listening songs (assume it as one task) on your mobile and at the same time your friend calls you, an interrupt is triggered upon which an interrupt service routine (ISR) signals the call processing task to wakeup.

kuldeep_ecb

Can we acquire mutex/semaphore in an Interrupt Service Routine?

An ISR will run asynchronously in the context of current running thread. It is not recommended to query (blocking call) the availability of synchronization primitives in an ISR. The ISR are meant be short, the call to mutex/semaphore may block the current running thread. However, an ISR can signal a semaphore or unlock a mutex.

kuldeep_ecb

Is it necessary that a thread must block always when resource is not available?

Not necessary. If the design is sure ‘what has to be done when resource is not available‘, the thread can take up that work (a different code branch). To support application requirements the OS provides non-blocking API.

For example POSIX pthread_mutex_trylock() API. When mutex is not available the function returns immediately whereas the API pthread_mutex_lock() blocks the thread till resource is available.

kuldeep_ecb

What we mean by “thread blocking on mutex/semaphore” when they are not available?

Every synchronization primitive has a waiting list associated with it. When the resource is not available, the requesting thread will be moved from the running list of processor to the waiting list of the synchronization primitive. When the resource is available, the higher priority thread on the waiting list gets the resource (more precisely, it depends on the scheduling policies).

kuldeep_ecb

What are events?

The semantics of mutex, semaphore, event, critical section, etc… are same. All are synchronization primitives. Based on their cost in using them they are different. We should consult the OS documentation for exact details.

kuldeep_ecb

What is a mutex and critical section?

Some operating systems use the same word critical section in the API. Usually a mutex is costly operation due to protection protocols associated with it. At last, the objective of mutex is atomic access. There are other ways to achieve atomic access like disabling interrupts which can be much faster but ruins responsiveness. The alternate API makes use of disabling interrupts.

kuldeep_ecb

Are binary semaphore and mutex same?

No. We suggest to treat them separately, as it is explained signalling vs locking mechanisms. But a binary semaphore may experience the same critical issues (e.g. priority inversion) associated with mutex.

kuldeep_ecb

What happens if a non-recursive mutex is locked more than once.

Deadlock. If a thread which had already locked a mutex, tries to lock the mutex again, it will enter into the waiting list of that mutex, which results in deadlock. It is because no other thread can unlock the mutex. An operating system implementer can exercise care in identifying the owner of mutex and return if it is already locked by same thread to prevent deadlocks.

kuldeep_ecb

Can a mutex be locked more than once?

A mutex is a lock. Only one state (locked/unlocked) is associated with it. However, a recursive mutexcan be locked more than once (POSIX complaint systems), in which a count is associated with it, yet retains only one state (locked/unlocked). The programmer must unlock the mutex as many number times as it was locked.

kuldeep_ecb

Can a thread acquire more than one lock (Mutex)?

Yes, it is possible that a thread is in need of more than one resource, hence the locks. If any lock is not available the thread will wait (block) on the lock.

kuldeep_ecb

Explain Binary and Counting Semaphore with an Example?

A semaphore is a generalized mutex. In a single buffer, we can split the 4 KB buffer into four 1 KB buffers (identical resources) , So here we can use counting Semaphore. single- single semaphore can be associated with these 4 buffers. So our Semaphore value will be 0 to 3. But in case of binary Semaphore we can only use 0 and 1.

IPC Interview Prepration

Suppose we have three threads T1, T2 and T3 which perform sequentially one after another is their any benefit of using thread over here rather than having a single process?

What is the use of thread over process?

What are the Advantages and disadvantages of script vs compiled program?

Mutex vs Semaphore

Howdy, Stranger!

Categories