thread.h

   1 // Copyright 2006 David Hilvert <dhilvert@auricle.dyndns.org>,
   2 //                              <dhilvert@ugcs.caltech.edu>
   3 //                              <dhilvert@gmail.com>
   4
   5 /*  This file is part of the Anti-Lamenessing Engine.
   6
   7     The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 3 of the License, or
  10     (at your option) any later version.
  11
  12     The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with the Anti-Lamenessing Engine; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20 */
  21
  22 /*
  23  * thread.h: threading details.
  24  */
  25
  26 #ifndef __thread_h__
  27 #define __thread_h__
  28
  29 #include <assert.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <stdlib.h>
  33
  34 #ifdef USE_PTHREAD
  35 #include <pthread.h>
  36 #endif
  37
  38 #define THREAD_PER_CPU_DEFAULT 1
  39 #define THREAD_COUNT_DEFAULT 4
  40
  41 class thread {
  42         static unsigned int _count;
  43         static unsigned int _cpu_count;
  44
  45         static void try_linux() {
  46                 assert (_cpu_count == 0);
  47
  48                 FILE *cpuinfo;
  49                 char buffer[100];
  50
  51                 cpuinfo = fopen("/proc/cpuinfo", "r");
  52
  53                 if (!cpuinfo)
  54                         return;
  55
  56                 while (!feof(cpuinfo)) {
  57                         fgets(buffer, 100, cpuinfo);
  58                         if (strncmp("processor", buffer, strlen("processor")))
  59                                 continue;
  60                         _cpu_count++;
  61                 }
  62         }
  63
  64 public:
  65         static void init() {
  66                 if (_cpu_count == 0) {
  67                         try_linux();
  68                 }
  69
  70                 if (_cpu_count > 0) {
  71                         _count = THREAD_PER_CPU_DEFAULT * _cpu_count;
  72                 } else {
  73                         _count = THREAD_COUNT_DEFAULT;
  74                 }
  75
  76                 assert (_count > 0);
  77         }
  78
  79         static void set_per_cpu(unsigned int new_per_cpu) {
  80                 if (_cpu_count == 0) {
  81                         fprintf(stderr, "\n\n");
  82                         fprintf(stderr, "Error: per-cpu thread count specified, but CPU count is unknown.\n");
  83                         fprintf(stderr, "       Try setting the thread count explicitly.\n");
  84
  85                         exit(1);
  86                 }
  87                 if (new_per_cpu == 0) {
  88                         fprintf(stderr, "\n\n");
  89                         fprintf(stderr, "Error: --per-cpu argument must be positive\n");
  90                         fprintf(stderr, "\n");
  91
  92                         exit(1);
  93                 }
  94
  95                 _count = _cpu_count * new_per_cpu;
  96                 assert (_count > 0);
  97         }
  98
  99         static void set_count(unsigned int new_count) {
 100                 if (new_count == 0) {
 101                         fprintf(stderr, "\n\n");
 102                         fprintf(stderr, "Error: --thread argument must be positive\n");
 103                         fprintf(stderr, "\n");
 104
 105                         exit(1);
 106                 }
 107
 108                 _count = new_count;
 109                 assert (_count > 0);
 110         }
 111
 112         static int count() {
 113                 assert (_count > 0);
 114                 return _count;
 115         }
 116
 117         class lock_t {
 118 #ifdef USE_PTHREAD
 119                 pthread_mutex_t _lock;
 120 #endif
 121         public:
 122                 lock_t() {
 123 #ifdef USE_PTHREAD
 124                         /* _lock = PTHREAD_MUTEX_INITIALIZER; */
 125                         pthread_mutex_init(&_lock, NULL);
 126 #endif
 127                 }
 128
 129                 void lock() {
 130 #ifdef USE_PTHREAD
 131                         pthread_mutex_lock(&_lock);
 132 #endif
 133                 }
 134
 135                 void unlock() {
 136 #ifdef USE_PTHREAD
 137                         pthread_mutex_unlock(&_lock);
 138 #endif
 139                 }
 140         };
 141
 142         class decompose_domain {
 143                 lock_t _lock;
 144                 int ilg, ihg, jlg, jhg;
 145
 146         protected:
 147                 void lock() {
 148                         _lock.lock();
 149                 }
 150
 151                 void unlock() {
 152                         _lock.unlock();
 153                 }
 154
 155                 virtual void prepare_subdomains(unsigned int threads) {
 156                 }
 157                 virtual void subdomain_algorithm(unsigned int thread,
 158                                 int il, int ih, int jl, int jh) {
 159                 }
 160                 virtual void finish_subdomains(unsigned int threads) {
 161                 }
 162
 163         private:
 164                 struct thread_data_t {
 165                         decompose_domain *this_ptr;
 166                         unsigned int thread_index;
 167                         int il, ih, jl, jh;
 168                 };
 169
 170                 static void *run_thread(void *thread_data) {
 171                         thread_data_t *td = (thread_data_t *) thread_data;
 172                         td->this_ptr->subdomain_algorithm(td->thread_index,
 173                                 td->il, td->ih, td->jl, td->jh);
 174                         return NULL;
 175                 }
 176
 177         public:
 178                 decompose_domain(int ilg, int ihg, int jlg, int jhg) {
 179                         this->ilg = ilg;
 180                         this->ihg = ihg;
 181                         this->jlg = jlg;
 182                         this->jhg = jhg;
 183                 }
 184
 185                 void run() {
 186                         int N;
 187 #ifdef USE_PTHREAD
 188                         N = thread::count();
 189
 190                         pthread_t *threads = (pthread_t *) malloc(sizeof(pthread_t) * N);
 191                         pthread_attr_t *thread_attr = (pthread_attr_t *)
 192                                         malloc(sizeof(pthread_attr_t) * N);
 193 #else
 194                         N = 1;
 195 #endif
 196
 197                         prepare_subdomains(N);
 198
 199                         thread_data_t *td = new thread_data_t[N];
 200
 201                         for (int ti = 0; ti < N; ti++) {
 202                                 td[ti].this_ptr = this;
 203                                 td[ti].thread_index = ti;
 204                                 td[ti].il = ilg + ((ihg - ilg) * ti) / N;
 205                                 td[ti].ih = ilg + ((ihg - ilg) * (ti + 1)) / N;
 206                                 td[ti].jl = jlg;
 207                                 td[ti].jh = jhg;
 208 #ifdef USE_PTHREAD
 209                                 pthread_attr_init(&thread_attr[ti]);
 210                                 pthread_attr_setdetachstate(&thread_attr[ti],
 211                                                 PTHREAD_CREATE_JOINABLE);
 212                                 pthread_create(&threads[ti], &thread_attr[ti],
 213                                                 run_thread, &td[ti]);
 214 #else
 215                                 run_thread(&td[ti]);
 216 #endif
 217                         }
 218
 219
 220 #ifdef USE_PTHREAD
 221                         for (int ti = 0; ti < N; ti++) {
 222                                 pthread_join(threads[ti], NULL);
 223                         }
 224
 225                         free(threads);
 226                         free(thread_attr);
 227 #endif
 228
 229
 230                         delete[] td;
 231
 232                         finish_subdomains(N);
 233                 }
 234
 235                 virtual ~decompose_domain() {
 236                 }
 237         };
 238 };
 239
 240 #endif