What is the difference between mutex and semaphore?

The difference between mutex and semaphore

Semaphores can be thought of as simple counters that indicate the status of a resource. This counter is a protected from user access and shielded by kernel.If counter is greater that 0, then the resource is available, and if the counter is 0 or less, then that resource is busy.

Semaphores can be either binary or counting, depending on the number of shared resources.semaphore available accessible to all processes so that they can read and check the value and also initialize and reinitialize the value of semaphore appropriately. For this reason only the semaphore is stored in kernel so that it can be accessed by all processes.

The command
$ ipcs –s
will give the list of existing semaphores.
-----------------------------------------------------------

Eg.
yoshi# ipcs -s
IPC status from /dev/kmem as of Mon Feb 7 11:21:36 2011
T ID KEY MODE OWNER GROUP
Semaphores:
s 0 0x4f1c02d4 --ra------- root root
s 1 0x411c1149 --ra-ra-ra- root root
s 2 0x4e0c0002 --ra-ra-ra- root root
s 3 0x41200ec8 --ra-ra-ra- root root
s 4 0x00446f6e --ra-r--r-- root root
s 25 0x410c035b --ra-ra-ra- root root
s 26 0x712068c5 --ra-ra-ra- root root
s 2075 0x00000000 --ra------- www other
s 28 0x00000000 --ra------- www other
-----------------------------------------------------------

Mutex can be released only by the thread that had acquired it where as in semaphore any thread can signal the semaphore to release the critical section.
There are 3 major differences between Mutex and Binary semaphore.

1. In case of Mutex semaphore the task that had taken the semaphore can only give it, however in the case of binary
semaphore any task can give the semaphore.
2. Calling SemFlush() function in Mutex is illegal.
3. Mutex Semaphore can not be given from an ISR.

Apart from counting behaviour the biggest differnce is in scope of mutex and semaphore. Mutex have process scope that is it is valid within a process space and can be used for thread synchronization (hence light weight), semaphore are can be used accross process space and hence can be used for inter process synch.

Shemaphores are of two types , binary and counting.counting shemaphore can range over an unrestricted domain ,where as binary semaphore which is also known as mutex can range between 0 and 1

Links :
1- http://www.allinterview.com/showanswers/105279.html
2- http://www.cs.cf.ac.uk/Dave/C/
3- http://www.minek.com/files/unix_examples/semab.html

4- http://www.ecst.csuchico.edu/~hilzer/csci640/pdf/

Windows and Unix way of dynamic link library management

Dynamic/Shared libraries: Differences Between Unix and Windows
[ On Unix, linking with a library creates a separate copy of it, But Windows will not create a copy. Its keeps a reference to the functions inside the libraries]


Unix and Windows use completely different paradigms for run-time loading of code. Before you try to build a module that can be dynamically loaded, be aware of how your system works.

In Unix, a shared object (.so) file contains code to be used by the program, and also the names of functions and data that it expects to find in the program. When the file is joined to the program, all references to those functions and data in the file's code are changed to point to the actual locations in the program where the functions and data are placed in memory. This is basically a link operation.

In Windows, a dynamic-link library (.dll) file has no dangling references. Instead, an access to functions or data goes through a lookup table. So the DLL code does not have to be fixed up at runtime to refer to the program's memory; instead, the code already uses the DLL's lookup table, and the lookup table is modified at runtime to point to the functions and data.

In Unix, there is only one type of library file (.a) which contains code from several object files (.o). During the link step to create a shared object file (.so), the linker may find that it doesn't know where an identifier is defined. The linker will look for it in the object files in the libraries; if it finds it, it will include all the code from that object file.

In Windows, there are two types of library, a static library and an import library (both called .lib). A static library is like a Unix .a file; it contains code to be included as necessary. An import library is basically used only to reassure the linker that a certain identifier is legal, and will be present in the program when the DLL is loaded. So the linker uses the information from the import library to build the lookup table for using identifiers that are not included in the DLL. When an application or a DLL is linked, an import library may be generated, which will need to be used for all future DLLs that depend on the symbols in the application or DLL.

Suppose you are building two dynamic-load modules, B and C, which should share another block of code A. On Unix, you would not pass A.a to the linker for B.so and C.so; that would cause it to be included twice, so that B and C would each have their own copy. In Windows, building A.dll will also build A.lib. You do pass A.lib to the linker for B and C. A.lib does not contain code; it just contains information which will be used at runtime to access A's code.

In Windows, using an import library is sort of like using "import spam"; it gives you access to spam's names, but does not create a separate copy. On Unix, linking with a library is more like "from spam import *"; it does create a separate copy.

STL- Containers

Vector
- Vectors are a kind of sequence containers. As such, their elements are ordered following a strict linear sequence.
- Vector containers are implemented as dynamic arrays; Just as regular arrays, vector containers have their elements stored in contiguous storage locations, which means that their elements can be accessed not only using iterators but also using offsets on regular pointers to elements.
- But unlike regular arrays, storage in vectors is handled automatically, allowing it to be expanded and contracted as needed.
- Vectors are good at:
* Accessing individual elements by their position index (constant time).
* Iterating over the elements in any order (linear time).
* Add and remove elements from its end (constant amortized time).
- Compared to arrays, they provide almost the same performance for these tasks, plus they have the ability to be easily re-sized. Although, they usually consume more memory than arrays when their capacity is handled automatically
Element access:
1 - operator[] - Access element at a particular locattion(ofset)
2 - at - Access element at a particular locattion(ofset)(throws exception, if fails).
3 - front - Access first element
4 - back - Access last element

Note:
- Internally, vectors -like all containers- have a size, which represents the amount of elements contained in the vector. But vectors, also have a capacity, which determines the amount of storage space they have allocated, and which can be either equal or greater than the actual size. When number of elements exhausted the capacity of Vector, reallocation of vectors will be required.
- Re-allocations may be a costly operation in terms of performance, since they generally involve the entire storage space used by the vector to be copied to a new location. Therefore, whenever large increases in size are planned for a vector, it is recommended to explicitly indicate a capacity for the vector using member function vector::reserve.
- How vector size is managed ? is it a continuous memory allocation or memory blocks are linked?
- Vectors are dynamic arrays, which have pre-defined capacity in the memory. when the elements are exhausted the capacity, the whole vector will be copied to new place for reallocation of the capacity.

List
- Lists are a kind of sequence containers. As such, their elements are ordered following a linear sequence.
- List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they contain in different and unrelated storage locations. The ordering is kept by the association to each element of a link to the element preceding it and a link to the element following it.
- This provides the following advantages to list containers:
* Efficient insertion and removal of elements anywhere in the container (constant time).
* Efficient moving elements and block of elements within the container or even between different containers (constant time).
* Iterating over the elements in forward or reverse order (linear time).
- Compared to other base standard sequence containers (vectors and deques), lists perform generally better in inserting, extracting and moving elements in any position within the container, and therefore also in algorithms that make intensive use of these, like sorting algorithms.
- The main drawback of lists compared to these other sequence containers is that they lack direct access to the elements by their position.

Set
- Sets are a kind of associative containers that stores unique elements, and in which the elements themselves are the keys.
- Internally, the elements in a set are always sorted from lower to higher following a specific strict weak ordering criterion set on container construction.
- Sets are typically implemented as binary search trees.
- Therefore, the main characteristics of set as an associative container are:
* Unique element values: no two elements in the set can compare equal to each other. For a similar associative container allowing for multiple equivalent elements, see multiset.
* The element value is the key itself. For a similar associative container where elements are accessed using a key, but map to a value different than this key, see map.
* Elements follow a strict weak ordering at all times. Unordered associative arrays, like unordered_set, are available in implementations following TR1.

Map
- Map is a Sorted Associative Container that associates objects of type Key with objects of type Data.
- Map is a Pair Associative Container, meaning that its value type is pair.
- It is also a Unique Associative Container, meaning that no two elements have the same key.
- Internally, the elements in the map are sorted from lower to higher key value following a specific strict weak ordering criterion set on construction
- As associative containers, they are especially designed to be efficient accessing its elements by their key
- Iterators are using to access the mapped value based on key.
- Iterators to elements of map,access to both the key and the mapped value

C++ Interview questions

[ Matter here is just notes. No authenticity can be assured]

How Exception can be handled at constructor ?
- When exception happened in constructor, destructor will not called and memory leak would happened.
- "function-try-block".is the mechanism, which can use to handle the exceptions at constructor.
- Or separate initialization functions can be used, instead of constructor.

Few Links :
- http://www.cs.technion.ac.il/~imaman/programs/throwingctor.html
- http://www.open-std.org/jtc1/sc22/open/n2356/except.html#except
- http://www.parashift.com/c++-faq-lite/exceptions.html
Notes :
- - A pointer declared inside try block will not be accesible in catch block.


How to make a procedure/function invisible to outside a library ?
- Declare the procedure or function as static. So the function can be accessible inside the file/library only.
Eg. static int get_user_conf()

How is the static variable and static functions in C++
- Static variables are part of class, not with object
- Static variable should be intialised after class definition.
eg. int base::counter=10;
- A non static function also can access static variables.
Eg. void increment_counter()
{
base::counter++; // base:: qualifier required.
}
- A static class can access only static variables, part of the class.

What is placement new ?
- Placement new is a mechanism in c++ which allows user to allocate memory from pre-allocated buffer.
- Standard C++ supports placement new operator, which constructs an object on a pre-allocated buffer (memory, which is already alocated). This is useful when building a memory pool, a garbage collector or simply when performance and exception safety are paramount (there's no danger of allocation failure since the memory has already been allocated, and constructing an object on a pre-allocated buffer takes less time):
Example :
void placement() {
char *buf = new char[1000]; //pre-allocated buffer
string *p = new (buf) string("hi"); //placement new
string *q = new string("hi"); //ordinary heap allocation
}

Installing Bash on HP-UX Itanium server

Installing Bash on HP-UX is different on different hardware. Currently HP-UX offers support on below hardware
- PA-RISC servers from HP
- Itanium(Intel I64) servers from HP.

I have been facing a difficulty on installing Bash over Itanium server. I found the bash depot in hp web site. Once I finished installation, bash throws an error with below message :
"/usr/lib/hpux32/dld.so: Unable to find library 'libtermcap.so'".

Here is a simple method to deploy Bash on HP-UX Itanium servers.

install bash-4.1.007-ia64-11.31.depot
( swinstall –s <bash-4.1.007-ia64-11.31.depot >
This depot can be downloaded from internet.http://hpux.connect.org.uk/hppd/hpux/Shells/bash-4.1.007/
Then you need to check for the dependencies, which  are installed or not. To check the dependency, go to the bash installed location. Usually the install directory will be /usr/local/bin/bash. Or you can execute below command to know the actual path
# whereis bash
Now you need to execute the bash.
If dependant  libraries are not present, then it will popup with a error message similar bas below :
"/usr/lib/hpux32/dld.so: Unable to find library 'libtermcap.so'"
If dependant libraries are not present in your system, here is the method to get it.
1- note down the bash dependant libraries  from here:

bash-4.1# ldd bash
        libtermcap.so =>        /usr/local/lib/hpux32/libtermcap.so
        libintl.so =>   /usr/local/lib/hpux32/libintl.so
        libiconv.so =>  /usr/local/lib/hpux32/libiconv.so
        libdl.so.1 =>   /usr/lib/hpux32/libdl.so.1
        libc.so.1 =>    /usr/lib/hpux32/libc.so.1
        libc.so.1 =>    /usr/lib/hpux32/libc.so.1

You can download all these files from  here : www.http://cmronweb.com/download/library-UX-itanium.rar

2- Now you need to copy all these files files from your friends machine to /usr/local/lib/hpux32/ folder. If hpux32 folder is not exist, then you can create one and copy the libriries to the folder.

3- Thats it, now you can enjoy the wonderful world of Bash.

C++ : New and Malloc

This small article is for C++ beginners, who is familiar with C. The dynamic memory allocation with C will be done with Malloc library function. In C++ it will be done with an operator new. Don't be confused, new is not a function, but a operator like +.- etc.. Here I will give you some example of how we use malloc and new.

//declaring native type

int* i1 = new int;
delete i1;
int* i2 = (int*) malloc(sizeof(int));
free(i2); //declaring native type array
char** c1 = new char*[10]; // Array allocation
delete[] c1; // cleaning array allocation
char** c2 = (char**) malloc(sizeof(char)*10);
// Allocation a two dimensional array in C
free(c2); 

Notes:
1- Since new/delete is an operator, you can overload it.

2- There is no alternative for C function realloc , in C++.

- You can use STL containers instead of new, if a realloc required( eg. std::vector<>::resize()).

- When explicit memory management is necessary, try to use smart pointers to make it easier and safer.

- Don't use malloc() or 'new' when containers or automatic variables can do the job.

3- new will call the appropriate construction to create the object. Similarly delete will call destructor.

4- No typecasting required for new.

5- malloc() returns NULL on failure while 'new' throws an exception.

6- malloc() allocates raw memory while 'new' constructs objects in the allocated space.
eg. shape * sp=new(12);

C source code : Linked list operations

#include <stdio.h>
#include <stdlib.h>
typedef struct list* node;

struct list {
    node next;
    int data;
};

node create_node(int val)
{
    node new_node=(node)malloc(sizeof(node));
    new_node->data=val;
    return new_node;
}
void insert_node(node head, int val, int pos)
{
    while(head->data!=pos)
    {
        head=head->next;

    }
    node tmp=head->next;
    head->next=create_node(val);
    head->next->next=tmp;

}

void print_list(node head)
{
    while(head!=NULL)
    {
        printf("%d - ",head->data);
        head=head->next;
    }
}

int main()
{
    int i;
    printf("Linked List operation\n");
    node head=create_node(0);
    node start=head;
    for(i=1;i<=10;i++)
    {
        head->next=create_node(i);
        head=head->next;
    }
    head->next=NULL;
    print_list(start);
    printf("\n Print the list after insertion");
    insert_node(start,15,5);
    printf("\n");
    print_list(start);
    return 0;
}