Program threaded-fft-mutex.cc

Transcription

1 1 // 2D FFT Using threads 2 // George F. Riley, Georgia Tech, Fall // This illustrates how a mutex would be implemented (both a "buggy" version 4 // and a good one). 5 6 #include <iostream> 7 8 #include "pthread.h" 9 #include "math.h" 10 #include <sys/time.h> #include "complex.h" 13 #include "InputImage.h" using namespace std; // This uses the Intel "Atomic Exchange" to help with mutex locking 18 uint32_t atomic_xchg32(volatile uint32_t *mem, uint32_t val) 19 { 20 uint32_t prev = val; asm volatile ("lock; xchgl %0, %1" 23 : "=r" (prev) 24 : "m" (*(mem)), "0"(prev) 25 : "memory"); 26 return prev; 27 } class BuggyMutex { 30 public: 31 BuggyMutex(); 32 void Lock(); // Lock the mutex 33 void UnLock(); // UnLock the mutex 34 private: // True if locked 35 bool locked; 36 }; BuggyMutex::BuggyMutex() 39 : locked(false) 40 { // Mutex is initially not locked 41 } void BuggyMutex::Lock() 44 { // This is buggy! Why? 45 // See if another thread has the mutex locked. If so, just "spin" 46 while(locked) 47 { // Do nothing.. THis is called "spinning" 48 } 49 // Lock is free, lock it and exit 50 locked = true; 51 } void BuggyMutex::UnLock() 54 { // Free the mutex 55 locked = false; 56 } Program threaded-fft-mutex.cc 1

2 57 58 class GoodMutex { 59 public: 60 GoodMutex(); 61 void Lock(); // Lock the mutex 62 void UnLock(); // UnLock the mutex 63 private: // True if locked 64 bool locked; 65 }; GoodMutex::GoodMutex() 68 : locked(false) 69 { // Mutex is initially not locked 70 } void GoodMutex::Lock() 73 { 74 // Use the atomic exchange to implement the locked flag 75 while(atomic_xchg32((uint32_t*)&locked, true)) 76 { // Another thread has the lock, do nothing. This is called "spinning" 77 } 78 // Lock is set true by atomic exchange, so nothing more needed 79 } void GoodMutex::UnLock() 82 { // Free the mutex 83 locked = false; 84 } // We use global variables in lieu of member variables for this example 87 Complex** h; // Points to the 2D array of complex (the input) 88 Complex* W; // Weights (computed once in main 89 unsigned N; // Number of elements (both width and height) 90 unsigned nthreads; // Desired number of threads 91 unsigned activecount = 0; // Number of active threads // pthread variables 94 // We will replace the activemutex and coutmutex with our 95 // two implementations to observe effects. We can t replace the exit mutex 96 // since it is needed for the condition variable (which we did not 97 // implement a replacement for. 98 BuggyMutex activemutex; 99 //GoodMutex activemutex; 100 pthread_mutex_t exitmutex; 101 pthread_cond_t exitcondition; 102 BuggyMutex coutmutex; 103 //GoodMutex coutmutex; // Add a verbose flag to turn on/off extra outputs 106 bool verbose = false; // Helper routines 109 void DumpTransformedValues() 110 { // Code omitted for brevity 111 } 112 2

3 113 void TransposeInPlace(Complex** m, int wh) 114 { // code omitted for brevity 115 } void LoadWeights() 119 { // Compute the needed W values. Omitted for brevity 120 } void Transform1D(Complex* h) 123 { // The simple 1D transform we did earlier. Code omitted for brevity 124 } 3

4 125 void* FFT_Thread(void* v) 126 { 127 unsigned long myid = (unsigned long)v; // My thread number 128 unsigned rowspercpu = N / nthreads; 129 unsigned myfirstrow = myid * rowspercpu; 130 // We have to do a mutex around the "activecount++". Why? 131 activemutex.lock(); 132 activecount++; 133 activemutex.unlock(); 134 if (verbose) 135 { 136 coutmutex.lock(); 137 cout << "MyId is " << myid << " myfirstrow " << myfirstrow << endl; 138 coutmutex.unlock(); 139 } 140 // Call the 1D FFT on each row 141 for (unsigned i = 0; i < rowspercpu; ++i) 142 { 143 Transform1D(h[myFirstRow + i]); 144 } 145 // Now notify the main thread we have completed the rows 146 pthread_mutex_lock(&exitmutex); // Insure only one thread signals the exit 147 activemutex.lock(); // Insure only one thread changes active 148 activecount--; 149 activemutex.unlock(); 150 // Don t need cout mutex here. Why? 151 cout << "Thread " << myid << " exited, activecount " << activecount << endl; 152 if (activecount == 0) 153 { // We are the last thread to exit. Signal the main thread 154 // that all threads are done 155 pthread_cond_signal(&exitcondition); 156 } 157 pthread_mutex_unlock(&exitmutex); 158 return 0; 159 } 4

5 160 int main( int argc, char** argv) 161 { 162 verbose = argc > 3; 163 InputImage image(argv[1]); 164 nthreads = atol(argv[2]); // Number of threads 165 N = image.getheight(); // Assume square, width = height 166 h = image.getrows(0, N); // In this case, we get all rows // Start the timer here, after loading the image 169 struct timeval tp; 170 gettimeofday(&tp, 0); 171 double startsec = tp.tv_sec + tp.tv_usec/ ; LoadWeights(); // Only need to do this once // Initialize the pthread mutex and condition variables 176 // The buggymutex variables are initialized in constructor 177 pthread_mutex_init(&exitmutex, 0); 178 pthread_cond_init(&exitcondition, 0); // We lock the exitmutex to be sure no threads exit until 181 // all threads created, and we are waiting on the condition signal 182 pthread_mutex_lock(&exitmutex); 183 // Create the threads 184 for (unsigned i = 0; i < nthreads; ++i) 185 { 186 pthread_t t; 187 pthread_create(&t, 0, FFT_Thread, (void*)i); 188 } 189 // Now wait for them to finish pass pthread_cond_wait(&exitcondition, &exitmutex); 191 if (verbose) cout << "All threads finished pass 1" << endl; // Transpose the matrix and schedule threads to do rows again 194 TransposeInPlace(h, N); 195 // Start the threads again 196 for (unsigned i = 0; i < nthreads; ++i) 197 { 198 pthread_t t; 199 pthread_create(&t, 0, FFT_Thread, (void*)i); 200 } 201 // Now wait for them to finish pass pthread_cond_wait(&exitcondition, &exitmutex); 203 if (verbose) cout << "All threads finished pass 2" << endl; // Transpose back and write results 206 TransposeInPlace(h, N); 207 gettimeofday(&tp, 0); 208 cout << "Calculated FFT " 209 << (tp.tv_sec+tp.tv_usec/ ) - startsec << " seconds" << endl; 210 DumpTransformedValues(); 211 } 212 5