using pthread_mutex_timedlock in linux.

We saw in the post " " how we can use mutexes in pthreads to achieve synchronization among various threads. Along with the the three functions we saw, there is a fourth mutex function that we can use when we want to wait on a mutex for only a specific duration and then continue irrespective of whether we are able to get a lock on the mutex or not. The function for timed operation on mutex it pthread_mutex_timedlock whose syntax is

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,const struct timespec *restrict abs_timeout);

The timeout is the time for which we want to wait on the mutex. To specify the timeout we need to use the structure timepsec which has two fields one for seconds and other for nanoseconds as shown below.

struct timespec { __time_t tv_sec; /* Seconds. */ long int tv_nsec; /* Nanoseconds. */ };

The mutex if available will be locked immediately, if the mutex is not available the thread will wait for the duration of time mentioned in the abs_timeout and then exit from the wait.

The following program shows an example of using the pthread_mutex_timedlock. In the program thread1 takes a value as input from the user and assigns it to a variable "temp". In thread2 the same variable is accessed and its value is printed. Thread1 locks a mutex while getting the value for temp from the user, but thread2 waits only for 5 seconds for the mutex to get unlocked after which it exits with a time out message and does not print the value of the variable temp.

To mention the timeout we need to first allocate memory for a timespec structure

struct timespec *wait wait=(struct timespec *)(malloc(sizeof(struct timespec)); wait->tv_sec=5; wait->tv_nsec=0;

Thus now we have a timespec structure with 5 seconds and 0 nanoseconds as the time values, which can be passed to the function pthread_mutex_timedlock to achieve a 5 second timeout.
The whole function looks as follows

#include<stdio.h> #include<stdlib.h> #include<pthread.h> #include<time.h> pthread_mutex_t mutex1,mutex2; #define perror(s) printf("\n" s "\n"); int temp; void * func1(){ pthread_mutex_lock(&mutex1); printf("\nEnter a value for temp\n"); scanf("%d",&temp); pthread_mutex_unlock(&mutex1); } void * func2() { struct timespec *wait; int ret; wait=(struct timespec *)(malloc(sizeof(struct timespec))); wait->tv_sec=5; wait->tv_nsec=0; sleep(5); ret=pthread_mutex_timedlock(&mutex1,wait); if(ret!=0){ perror("Wait timed out"); return ; } printf("\nvalue assigned for temp is %d\n",temp); pthread_mutex_unlock(&mutex1); } main() { int ret; pthread_t thread1,thread2; ret=pthread_create(&thread1,NULL,&func1,NULL); if(ret!=0){ perror("Unable to create thread"); } ret=pthread_create(&thread2,NULL,&func2,NULL); if(ret!=0){ perror("Unable to create thread"); } printf("Created threads"); pthread_join(thread1,NULL); pthread_join(thread2,NULL); }

Save the program as mutex_timedlock.c, and compile it with the flag -lpthread

$ cc -lpthread -o mutex_timedloc mutex_timedlock.c

While executing the program when the prompt for entering a value for the variable appears, if you wait for more than 5 seonds for entering the value, you will noticed the timed out message from the second thread will appear on the other hand if we enter the value with in 5 seconds the value entered is printed by the second thread. case1: Waiting for more than 5 seconds before entering the value

$ ./mutex_timedlock Created threads Enter a value for temp Wait timed out 5

Created threads Enter a value for temp 5 value assigned for temp is 5

Thus we are able to achieve a mutex lock for a specific duration using the pthread_mutex_timedlock function.

Animated gif image of linux using gimp

Here are steps of how we can create the following animated linux gif image using gimp.

Note: This was created using gmip 2.6.10

Open gimp and go to

file->create->logos->cool_metal

This will show a menu as shown below.

In the field marked "text" , enter L, choose the font size that you would like and then click on the gradient to pick the color gradient you wish for the text.

The animation shown below uses the incandescent.

This will create a image as shown below.

Save the image as L.jpg. While saving remeber to take the file type as .jpg.

Following the same steps create the other images with the following text

LI LIN LINU LINUX

Now Open gimp again.

click on file->new->template

choose the size of the template you want, (Base it on the size of the font that you have created).

Now drag and drop the 4 jpg images that we created above in the order

L.jpg LI.jpg LIN.jpg LINU.jpg LINUX.pg

Download an image of tux, the penguin, from net if you want to and add that too to the gimp.

You should see all the six images in six layers as shown below.

Now to create an animation using these layers, click on save as and choose the image type to be .gif and add the extention to the name while saving as shown below

Before saving a window will appear, confirming whether you want to save as animation or just as an image, choose save as animation, and click on export

In the next window shown below, you can choose how much dealy should be given between every frame. The more delay you give the slower the animation will look. Check the loop for ever button to keep running the animation infinietly and click on save.

Now your gif animated image should be ready.

ussing barriers in pthreads

pthreads allows us to create and manage threads in a program. When multiple threads are working together, it might be required that the threads wait for each other at a certain event or point in the program before proceeding ahead.

Let us say we have four threads, each of which is going to initialize a global variable. The 4 variables in turn might be used by all the four threads. Thus it would be feasible that all the threads wait for each other to finish the initialization of the variables before proceeding.

Such operations can be implemented by adding a barrier in the thread. A barrier is a point where the thread is going to wait for other threads and will proceed further only when predefined number of threads reach the same barrier in their respective programs.

To use a barrier we need to use variables of the type pthread_barrier_t. A barrier can be initialized using the function pthread_barrier_init, whose syntax is

int pthread_barrier_init(pthread_barrier_t *restrict barrier,const pthread_barrierattr_t *restrict attr, unsigned count); Arguments: barrier: The variable used for the barrier attr: Attributes for the barrier, which can be set to NULL to use default attributes count: Number of threads which must wait call pthread_barrier_wait on this barrier before the threads can proceed further.

Once a barrier in initialized, a thread can be made to wait on the barrier for other threads using the function pthread_barrier_wait whose syntax is

int pthread_barrier_wait(pthread_barrier_t *barrier);

Where the barrier is the same variable initialized using pthread_barrier_init.

A thread will keep waiting till the "count" number of threads passed during init do not call the wait function on the same barrier.

In the example below, we create 4 threads, and each thread assigns a value to one of he global variables and then later all the threads print the value of all the four variables. Thus to be able to print the value of all the variables the threads have to wait until all threads have not finished assigning the values. Thus we can make use of barriers to make the threads wait.

The init function :

pthread_barrier_init(&our_barrier,NULL,4);

initializes the barrier "our_barrier" to wait for four threads.

Thus till all the four threads have not called the pthread_barrier_wait the other threads will continue to wait.

Once pthread_barrier_wait has been called by 4 threads, all the threads will continue their execution of program.

A barrier can be destroyed using the function pthread_barrier_destroy, whose syntax is :

int pthread_barrier_destroy(pthread_barrier_t *barrier);

But note that the barrier should be destroyed only when no thread is executing a wait on the barrier.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> int t1,t2,t3,t4; pthread_barrier_t our_barrier; void *thread1() { sleep(2); printf("Enter value for t1: "); scanf("%d",&t1); pthread_barrier_wait(&our_barrier); printf("\nvalues entered by the threads are %d %d %d %d \n",t1,t2,t3,t4); } void *thread2() { sleep(4); printf("Enter value for t2: "); scanf("%d",&t2); pthread_barrier_wait(&our_barrier); printf("\nvalues entered by the threads are %d %d %d %d \n",t1,t2,t3,t4); } void *thread3() { sleep(6); printf("Enter value for t3: "); scanf("%d",&t3); pthread_barrier_wait(&our_barrier); printf("\nvalues entered by the threads are %d %d %d %d \n",t1,t2,t3,t4); } void *thread4() { int temp; sleep(8); printf("Enter value for t4: "); scanf("%d",&t4); pthread_barrier_wait(&our_barrier); printf("\nvalues entered by the threads are %d %d %d %d \n",t1,t2,t3,t4); } main() { pthread_t thread_id_1,thread_id_2,thread_id_3,thread_id_4; pthread_attr_t attr; int ret; void *res; pthread_barrier_init(&our_barrier,NULL,4); ret=pthread_create(&thread_id_1,NULL,&thread1,NULL); if(ret!=0) { printf("Unable to create thread1"); } ret=pthread_create(&thread_id_2,NULL,&thread2,NULL); if(ret!=0) { printf("Unable to create thread2"); } ret=pthread_create(&thread_id_3,NULL,&thread3,NULL); if(ret!=0) { printf("Unable to create thread3"); } ret=pthread_create(&thread_id_4,NULL,&thread4,NULL); if(ret!=0) { printf("Unable to create thread4"); } printf("\n Created threads \n"); pthread_join(thread_id_1,NULL); pthread_join(thread_id_2,NULL); pthread_join(thread_id_3,NULL); pthread_join(thread_id_4,NULL); pthread_barrier_destroy(&our_barrier); }

Save the program as pthread_barrier.c and compile it by passing the -lpthread flag.

$ cc -lpthread -o pthread_barrier pthread_barrier.c $ ./pthread_barrier Enter value for t1: 10 Enter value for t2: 20 Enter value for t3: 30 Enter value for t4: 40 values entered by the threads are 10 20 30 40 values entered by the threads are 10 20 30 40 values entered by the threads are 10 20 30 40 values entered by the threads are 10 20 30 40

To stress on usefulness of the barrier, we can change barrier initialization in the above code to wait for only 3 threads i.e.

pthread_barrier_init(&our_barrier,NULL,3);
And remove the pthread_barrier_wait from the the 4th thread.

After the above changes, if we compile and execute the code the output would be

Created threads Enter value for t1: 10 Enter value for t2: 20 Enter value for t3: 30 values entered by the threads are 10 20 30 0 values entered by the threads are 10 20 30 0 values entered by the threads are 10 20 30 0 Enter value for t4: 40 values entered by the threads are 10 20 30 40

The first three threads could not get the value entered by the fourth thread as they moved over the barrier as soon as three threads executed the wait function.

Converting pdf to text in linux

The contents of a pdf file can be converted to a simple text file using the tool "pdftotext". The format of using pdftotext is

$ pdftotext -f <start page number> -l <end page number> <pdf file name> <output text file name>

Let us say we have a pdf file by the name temp.pdf, of which we want to convert to text the page numbers 1 to 4 and create a text file by the name output.txt .

$ pdftotext -f 1 -l 4 temp.pdf output.txt $ ls output.txt temp.pdf

The file output.txt will have all the text contents of the temp.pdf, pages 1 to 4 but will not contain the images. The formatting by default in not maintained in the text file.

To be able to maintain the formatting also we need to pass the option -layout.

$ pdftotext -f 1 -l 4 -layout temp.pdf output.txt

Now the text file will have almost the same format as the pdf file.

Using condition variables in pthreads

Along with mutexes, pthreads gives us another tool for synchronization between the threads, condition variables. Condition variables are variables of the kind pthread_cond_t.

When a thread is waiting on a mutex it will continuously keep polling on the mutex waiting for it to get unlocked. Such behavior could lead to wastage of CPU resources. This can be prevented by using the condition variables.

The condition variables can be initialized statically

pthread_cond_t cond_var=PTHREAD_COND_INTIALIZER

or dynamically

pthread_cond_init(<condition variable>,<attribute>).

Attribute can be left NULL if default attributes are sufficient. The only attribute condition variables have is process_shared, which indicates that the condition variable is visible to threads of other processes too.

Now to use the condition variable in a thread we have two functions

pthread_cond_wait(<condition variable>,<mutex>);

This is called when a thread wants to wait for specific task to be completed by another thread before continuing its operations. This function should be called after locking the mutex, which automatically gets unlocked once the thread goes in to wait state.

pthread_cond_signal(<condition variable>);

This function does the job of signaling to the thread that had called pthread_cond_wait. Note that the "condition variable" used in the signal and the wait functions should be the same. We need to lock the mutex that is shared by the threads before calling this function and unlock it after the call.

Once pthread_cond_signal is called the threas which was waiting on the function pthread_cond_wait will proceed with its execution.

The following program depicts the use of condition variables.
We create two threads
"fill": which fills values into an array "arr"
read: Which reads the values of the array.

Now we can read from the array unless it is not filled, thus the thread read calls pthread_cond_wait, waiting for the array to be filled. On the other hand the thread "fill" calls pthread_cond_signal once it is done filling the array.Thus making sure that the threads are in synchronization.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t fill_mutex; int arr[10]; int flag=0; pthread_cond_t cond_var=PTHREAD_COND_INITIALIZER; void *fill() { int i=0; printf("\nEnter values\n"); for(i=0;i<4;i++) { scanf("%d",&arr[i]); } pthread_mutex_lock(&fill_mutex); pthread_cond_signal(&cond_var); pthread_mutex_unlock(&fill_mutex); pthread_exit(NULL); } void *read() { int i=0; pthread_mutex_lock(&fill_mutex); pthread_cond_wait(&cond_var,&fill_mutex); pthread_mutex_unlock(&fill_mutex); printf("Values filled in array are"); for(i=0;i<4;i++) { printf("\n %d \n",arr[i]); } pthread_exit(NULL); } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&fill,NULL); ret=pthread_create(&thread_id1,NULL,&read,NULL); printf("\n Created threads"); pthread_join(thread_id,&res); pthread_join(thread_id1,&res); }

Save the program as pthread_cond.c, and compile using -lpthread flag

cc -lptread -o pthread_cond pthread_cond.c

Execute the program

$ ./pthread_cond $ Created threads Enter values 10 20 30 40 Values filled in array are 10 20 30 40

Thus we can see that the read thread was waiting until the fill thread did not call the signal, and only after receiving the signal the read thread continued execution.

Searching and highlighting in vi editor

In this post we will look into at the ways in which we can search in a program using the VI editor.

The searching always happens in the command mode so if you want to search for a string or a pattern in the program, first step is to go to the command mode by pressing "esc"

Let us take a simple hello world program as an example.
#include<stdio.h> main() { printf("Hello world"); printf("world"); }

Let us say we come across the string printf once and want to search all the occurrences of printf after the current cursor position, then just move the cursor on printf and press "*". The cursor will automatically move to the next occurrence of printf and on each press of "*" it will move to the next occurrence of printf.

To search backwards, that is behind the current cursor position place the cursor on printf and press "#". The cursor will move to the previous occurence of the search string. The second way of searching is
Go to command mode and type /<search string>

any thing that follows the "/" will be taken as the search string.

Then keep pressing "n" to move to the next occurrences of the search string. If you want to move back in the document, that is search for occurrences of the string before the current cursor position use the shift "n" , i.e "N" .
To see all the matching strings at the same time we can highlight all the matched strings by setting the option hlsearch i.e.

:set hlsearch

All the items which matched the previous search string will get highlighted. To remove the highlight run the command

:nohlsearch

To make the seach case insensitive we need to set the option "ignorecase" i.e

set ignorecase

The search can be made case insensitive by adding \c to the search string, i.e

/<search sting>\c/

The search can also be restrcted to specific lines. To restict the search only to a single line we need to use \%numl along with the search string. To restrict the search for strintg printf to 20th line we need to use

/\%20l\printf/

To restinct the search to lines after 20th line

/\>%20l\printf/

To restinct the search to lines between 20th line and 30th lines

/\>%20l\%<30l\printf/

The same rules can be applied to columns instead of lines by replacing "l" in the command by "c".

We can also highlight patterns with color of our own wish by using the command "match". Let us say we want to highlight all the strings "printf" in red color. Then first we need to create a hightlight group by running the command

:highlight group1 ctermbg=red guibg=red

Instead of group1 we can use any group name we want, and instead of red we can use any other color name that is recognized by "vi".
Now use the command match to highlight the string printf.

match group1 /printf/

group1 being the name we used while creating our group using highlight command. All the occurrences of string printf should get highlighted in red, or whatever color is chosen while running the highlight command.

To remove the highlight run the command

match none

Enabling mouse in vi editor in linux

While using the "vi" editor, one of the common problmes that we face is the inability to the mouse to move around in the file. Here is simple way to enable to usage of mouse in vi editor.

Open the vi editor in the command mode (Press "esc" to enter command mode) run the command

set mouse=a

Now you should be able to click any where in the document and the cursor will move to that location.

To enable the mouse every time "vi" is launched we need to open the file

/etc/vim/vimrc

And uncomment the line

"set mouse=a"

Note: un-commenting is done by removing the ' " ' at the beginning of the line.

Save and close the file. From the next time any file is opened using "vi" editor the mouse will be enabled by default.

Extracting images from pdf file from command line in linux

if we want to extract only the images from a pdf file, we can use the command line tool pdfimages. pdfimages extracts the images from the given pdf, from the pages we mention and saves it in the .ppm format. The syntax for using the command is

$ pdfimages -f <starting page number> -l <ending page number> <name of pdf file> <image-root>

Image-root is nothing but prefix for the filenames of the image files to be created.

Let us say we have a file by the name temp.pdf, from which we want to extract the images from the pages 2 to 4 assume there are three images.

$ pdfimages -f 2 -l 4 temp.pdf images $ ls image-000.ppm image-001 image-002 temp.pdf

Thus we can see that the three images are extracted and stored as image-000.ppm,image-001.ppm,image-002.ppm.

If the file is password locked we can pass the password using the option -upw along with the command.

Creating a password locked pdf document in linux

We can user pdftk tool to create a password locked pdf file i.e. to open the pdf file we need to open the supply a password.

The options that have to be passed to pdftk are

$ pdftk <input_pdf_file> output <output_pdf_file> encrypt40bit user_pw <Password_for_the_file>

Let us say we have a file temp.pdf and we want to have the password "hello" for opening the file and we will call the new file by the name temp_passwd.pdf

$ pdftk temp.pdf output temp_passwd.pdf encrypt_40bit user_pw "hello"

Now if we try to open the file temp_passwd.pdf we will be prompted for a password and the file will open only if we pass the password "hello".

In the command we also use encrypt_128bit instead of encrypt_40bit.

Splitting a pdf file into seperate pdfs in linux

The pdftk tool can be used to split a given pdf document into separate individual pdf pages. The option to be used with pdftk to achieve this is "burst" i.e.

$ pdftk <input pdf file> burst"

The pages are created with the names as pg_0001.pdf for first page,pg_0002.pdf for the second page etc. Example : Let us say we have a pdf file named "temp.pdf" with 10 pages.

$ pdftk temp.pdf burst $ ls doc_data.txt pg_0003.pdf pg_0005.pdf pg_0007.pdf pg_0009.pdf temp.pdf pg_0001.pdf pg_0004.pdf pg_0006.pdf pg_0008.pdf pg_0010.pdf

Thus we can see the temp.pdf has been split into 10 pdf files. The file doc_data.txt has the information of the document.

Using pthread_mutex_trylock

In the mutex we saw in the post " " , if a mutex is locked by one thread, other threads will wait infinitesly for the mutex when pthread_mutex_lock is called. The other threads wil get out pf hte wait only when the mutex becomes available or the process is killed.
If such a behviour of infinite wait is undesirable we can use the variant pthread_mutex_trylock.

In this function the thread will try to lock the mutex, but in case the mutes in not available, it will return with an error EBUSY and will not try to acuire the lock again . If it is able to lock the mutex, the return value is 0 else it returns a non zero error value.

The following code shows the use of the function pthread_mutex_trylock. In the program, two threads are created one to write to a file and another to read from the file. The read thread is started with a little delay to allow the write thread to get access of the mutex.

Both the thread lock the muetx using pthread_mutex_trylock. The write thread is able to get access to the lock and continues with the execution of the thread. The read thread on the other hand tries to access the lock but is unaalbe to get a lock on the mutex as the write thread is holding the same. Thus it returns with an error value, because of which the thread has to be exited with our reading the file.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t rw_mutex; void * write(void *temp) { char *ret; FILE *file1; char *str; int retur; retur=pthread_mutex_trylock(&rw_mutex); if(retur!=0) { printf("Unable to get lock"); } printf("\nFile locked, please enter the message \n"); str=(char *)malloc(10*sizeof(char)); file1=fopen("temp","w"); scanf("%s",str); fprintf(file1,"%s",str); fclose(file1); sleep(5); pthread_mutex_unlock(&rw_mutex); printf("\nUnlocked the file you can read it now \n"); return ret; } void * read(void *temp) { char *ret; FILE *file1; char *str; int retur; sleep(5); retur=pthread_mutex_trylock(&rw_mutex); if(retur!=0) { printf("Unable to getlock"); return retur; } printf("\nOpening file for reading\n"); file1=fopen("temp","r"); str=(char *)malloc(10*sizeof(char)); fscanf(file1,"%s",str); printf("\nMessage from file is %s \n",str); fclose(file1); pthread_mutex_unlock(&rw_mutex); return ret; } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&write,NULL); ret=pthread_create(&thread_id1,NULL,&read,NULL); pthread_join(thread_id,&res); pthread_join(thread_id1,&res); }

Save the file as mutex_trylock.c, and compile it using the flab -lpthread

$ cc -lpthread -o mutex_trylock mutex_trylock.c $ ./mutex_trylock File locked, please enter the message Hello Unable to getlock Unlocked the file you can read it now

We can see from the messages that the read thread has returned with an error and was unable to open the file as the pthread_mutex_trylock failed to get the lock.