EmbLogic's Blog

Hi ,

Lets discuss about memory allocation techniques we use either in user space program or kernel space program .

1. Malloc :-

void *malloc(size_t size);
The malloc() function allocates size bytes and returns a pointer to the
allocated memory.  The memory is not initialized.  If size is  0,  then
malloc()  returns either NULL, or a unique pointer value that can later
be successfully passed to free().

2. Kmalloc

void *kmalloc(size_t size , flage);

Kmalloc allocates memory from kernel space and returns a pointer to the allocated memory .kmalloc allocated physically contiguous memory . if kernel doesn’t find contiguous memory of required size then this call fails .

3. vmalloc

void * vmalloc(size_t size);

vmalloc allocates virtually contiguous memory not necessary to be physically contiguous .vmalloc is a slower operation (slower because it makes an extra table to map the contiguous virtual memory to non-contiguous physical memory) . vmalloc is used when we need a large memory from kernel space .

Thank you ……

-> Pointers in c is variable which points the value stored in another location
-> It stores the logical addresses of the variable in which data is stored
->Size of a pointer depends on architecture of a workstation i.e
4bytes for 32 bit and 8bytes for 64 bit architecture
-> Representation of pointers
int *ptr;
//above expression points to the integer value stored in some location of memory.
-> Example
int *ptr;
int var=5;
ptr=&var;
printf(“Location stored in ptr is %p \n”,ptr); // ( it will print the the logical address of of varible var )

printf(“address of var is %x “,&var); // it will print the address of var

NOTE: check both the values and see the result …….
thank you

If we use single malloc for a double pointer then it simply means that the memory is allocated to the for the external Pointer

i.e, malloc(**ptr) -> Memory is allocated only for external pointer of  *(*ptr) which is allocated in form of array. But to provide (*ptr) a memory location , we have to malloc() it again as follows:

malloc(*ptr) ->Now memory is allocated for *ptr .

To  check the amount of memory allocated under **ptr , just print using %d format specifier and as an argument to printf call sizeof(**ptr) .

i.e,

printf(“The size under **ptr is :%d \n”,sizeof(**ptr));

There are different types of INTER PROCESSING COMMUNICATION techniques :–

1)Pipes, 2)FIFO, 3) shared memory, 4)message queue

Message queue is a technique through which we can send & receive data.

In message queues data is send with data type along with data, as the data type of each message is different there is less synchronization problem.

Behaviour of pipes
*pipes provide unidirectional data channel (half duplex ),provides a read and write file descriptors
*the communication channel provided by a pipe transfers data in the form of byte stream
*if a process attempts to read from empty pipe provided both the file descriptors are open we will observe a block on read
*if a process atempts to write on a full pipe , with both descriptors open then we will observe a block on write
*if writing side has been closed and there exists some data in the pipe then reader could read till EOF
*if all the read descriptors are closed, then a attempt to write will cause a SIGPIPE signal to the calling process
*pipes can be made non blocking types using O_NONBLOCK in the flag

Simple Algorithm to initialise a Scull

1->Register device

2->Give memory to scull device

3->Set this memory to NULL using memset

4->After this initialise device

5->Get device status

->>Use Insmod to add to kernel

->>Use rmmod to remove from kernel

We can change the thread attributes by modifying the pthread_attr_t structure.

Generally we give NULL in pthread_create , so it takes default attributes while creating a thread , but we can modify this by giving a pointer pointing to pthread_attr_t structure instead of giving null i:e;

pthread_create(pthread_t thid, pthread_attr_t *attr, void*(*start_routine)(void *), void *arg);