Consider the following function $($part of a larger program$)$ which applies a blur to an image.

This filter is implemented using an averaging method $($i$.$e$.,$ like your homework$).$ Does this

code handle threads efficiently, or inefficiently? Explain.

$//$Assume that the program compiles and $//$produces the expected result

pthread$\_$t tids$[$THREAD$\_$COUNT$]$;

Pixel$**$ input;

Pixel$**$ output;

pthread$\_$mutex$\_$t output$\_$mutex;

$//$OMITTED: main method that loads file, calls $//$process$\_$image, and saves the file.

int process$\_$image$()\{$

for$($int i$=0$; i $<$ THREAD$\_$COUNT; i$++)$

pthread$\_$create$($&tids$[$i$],$ NULL, blur, i$)$;

for$($int $=0$; i $<$ THREAD$\_$COUNT; i$++)$

pthread$\_$join$($&tids$[$i$],$ NULL$)$;

$\}$

void$*$ blur$($void$*$ arg$)\{$

pthread$\_$mutex$\_$lock$($output$\_$mutex$)$;

$//$all the filter code goes here and works on $//$column

pthread$\_$mutex$\_$unlock$($output$\_$mutex$)$

pthread$\_$exit$(0)$;

$\}$

Efficiently $-$it creates threads, and uses different memory allocations for each of the threads

Efficiently $-$ it creates threads, gives them an opportunity to do computation in parallel, and then joins

all of them

Inefficiently $-$ the thread join happens after each thread create so only one thread is in existence at a

time.

Inefficiently $-$ the critical section contains almost the entire blur function so only one thread can

actually run at a time