← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/my_thr_init.cc

  • Committer: Monty Taylor
  • Date: 2010-08-12 20:27:32 UTC
  • mto: (1720.1.5 build)
  • mto: This revision was merged to the branch mainline in revision 1722.
  • Revision ID: mordred@inaugust.com-20100812202732-9kzchbkvkyki4n3u
Merged libdrizzle directly into tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/my_thr_init.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/*
17
17
  Functions to handle initializating and allocationg of all mysys & debug
18
18
  thread variables.
19
19
*/
20
20
 
21
 
#include <config.h>
 
21
#include "config.h"
22
22
 
23
 
#include <drizzled/internal/my_sys.h>
24
 
#include <drizzled/internal/thread_var.h>
25
 
#include <drizzled/internal/m_string.h>
 
23
#include "drizzled/internal/my_sys.h"
 
24
#include "drizzled/internal/my_pthread.h"
 
25
#include "drizzled/internal/thread_var.h"
 
26
#include "drizzled/internal/m_string.h"
26
27
 
27
28
#include <cstdio>
28
29
#include <signal.h>
38
39
# endif
39
40
#endif
40
41
 
41
 
#include <boost/thread/thread.hpp>
42
 
#include <boost/thread/mutex.hpp>
43
 
#include <boost/thread/tss.hpp>
44
 
 
45
42
namespace drizzled
46
43
{
47
44
namespace internal
48
45
{
49
46
 
50
 
boost::thread_specific_ptr<st_my_thread_var> THR_KEY_mysys;
51
 
boost::mutex THR_LOCK_threads;
 
47
uint32_t thd_lib_detected= 0;
 
48
 
 
49
pthread_key_t THR_KEY_mysys;
 
50
pthread_mutex_t THR_LOCK_lock;
 
51
pthread_mutex_t THR_LOCK_threads;
 
52
pthread_cond_t  THR_COND_threads;
 
53
uint32_t            THR_thread_count= 0;
 
54
static uint32_t my_thread_end_wait_time= 5;
 
55
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 
56
pthread_mutexattr_t my_fast_mutexattr;
 
57
#endif
 
58
 
 
59
static uint32_t get_thread_lib(void);
52
60
 
53
61
/*
54
62
  initialize thread environment
63
71
 
64
72
bool my_thread_global_init(void)
65
73
{
 
74
  int pth_ret;
 
75
  thd_lib_detected= get_thread_lib();
 
76
 
 
77
  if ((pth_ret= pthread_key_create(&THR_KEY_mysys, NULL)) != 0)
 
78
  {
 
79
    fprintf(stderr,"Can't initialize threads: error %d\n", pth_ret);
 
80
    return 1;
 
81
  }
 
82
 
 
83
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 
84
  /*
 
85
    Set mutex type to "fast" a.k.a "adaptive"
 
86
 
 
87
    In this case the thread may steal the mutex from some other thread
 
88
    that is waiting for the same mutex.  This will save us some
 
89
    context switches but may cause a thread to 'starve forever' while
 
90
    waiting for the mutex (not likely if the code within the mutex is
 
91
    short).
 
92
  */
 
93
  pthread_mutexattr_init(&my_fast_mutexattr);
 
94
  pthread_mutexattr_settype(&my_fast_mutexattr,
 
95
                            PTHREAD_MUTEX_ADAPTIVE_NP);
 
96
#endif
 
97
 
 
98
  pthread_mutex_init(&THR_LOCK_lock,MY_MUTEX_INIT_FAST);
 
99
  pthread_mutex_init(&THR_LOCK_threads,MY_MUTEX_INIT_FAST);
 
100
  pthread_cond_init(&THR_COND_threads, NULL);
66
101
  if (my_thread_init())
67
102
  {
68
103
    my_thread_global_end();                     /* Clean up */
74
109
 
75
110
void my_thread_global_end(void)
76
111
{
 
112
  struct timespec abstime;
 
113
  bool all_threads_killed= 1;
 
114
 
 
115
  set_timespec(abstime, my_thread_end_wait_time);
 
116
  pthread_mutex_lock(&THR_LOCK_threads);
 
117
  while (THR_thread_count > 0)
 
118
  {
 
119
    int error= pthread_cond_timedwait(&THR_COND_threads, &THR_LOCK_threads,
 
120
                                      &abstime);
 
121
    if (error == ETIMEDOUT || error == ETIME)
 
122
    {
 
123
      /*
 
124
        We shouldn't give an error here, because if we don't have
 
125
        pthread_kill(), programs like mysqld can't ensure that all threads
 
126
        are killed when we enter here.
 
127
      */
 
128
      if (THR_thread_count)
 
129
        fprintf(stderr,
 
130
                "Error in my_thread_global_end(): %d threads didn't exit\n",
 
131
                THR_thread_count);
 
132
      all_threads_killed= 0;
 
133
      break;
 
134
    }
 
135
  }
 
136
  pthread_mutex_unlock(&THR_LOCK_threads);
 
137
 
 
138
  pthread_key_delete(THR_KEY_mysys);
 
139
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 
140
  pthread_mutexattr_destroy(&my_fast_mutexattr);
 
141
#endif
 
142
  pthread_mutex_destroy(&THR_LOCK_lock);
 
143
  if (all_threads_killed)
 
144
  {
 
145
    pthread_mutex_destroy(&THR_LOCK_threads);
 
146
    pthread_cond_destroy(&THR_COND_threads);
 
147
  }
77
148
}
78
149
 
79
150
static uint64_t thread_id= 0;
91
162
 
92
163
bool my_thread_init(void)
93
164
{
94
 
  // We should mever see my_thread_init()  called twice
95
 
  if (THR_KEY_mysys.get())
96
 
    return 0;
97
 
 
98
 
  st_my_thread_var *tmp= new st_my_thread_var;
 
165
  bool error=0;
 
166
  st_my_thread_var *tmp= NULL;
 
167
 
 
168
#ifdef EXTRA_DEBUG_THREADS
 
169
  fprintf(stderr,"my_thread_init(): thread_id: 0x%lx\n",
 
170
          (uint32_t) pthread_self());
 
171
#endif
 
172
 
 
173
  if (pthread_getspecific(THR_KEY_mysys))
 
174
  {
 
175
#ifdef EXTRA_DEBUG_THREADS
 
176
    fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
 
177
            (long) pthread_self());
 
178
#endif
 
179
    goto end;
 
180
  }
 
181
  tmp= static_cast<st_my_thread_var *>(calloc(1, sizeof(*tmp)));
99
182
  if (tmp == NULL)
100
183
  {
101
 
    return true;
 
184
    error= 1;
 
185
    goto end;
102
186
  }
103
 
  THR_KEY_mysys.reset(tmp);
 
187
  pthread_setspecific(THR_KEY_mysys,tmp);
 
188
  tmp->pthread_self= pthread_self();
 
189
  pthread_mutex_init(&tmp->mutex,MY_MUTEX_INIT_FAST);
 
190
  pthread_cond_init(&tmp->suspend, NULL);
 
191
  tmp->init= 1;
104
192
 
105
 
  boost::mutex::scoped_lock scopedLock(THR_LOCK_threads);
 
193
  pthread_mutex_lock(&THR_LOCK_threads);
106
194
  tmp->id= ++thread_id;
 
195
  ++THR_thread_count;
 
196
  pthread_mutex_unlock(&THR_LOCK_threads);
107
197
 
108
 
  return false;
 
198
end:
 
199
  return error;
109
200
}
110
201
 
111
202
 
117
208
 
118
209
  NOTE
119
210
    This may be called multiple times for a thread.
120
 
    This happens for example when one calls 'server_init()'
121
 
    server_end() and then ends with a end().
 
211
    This happens for example when one calls 'mysql_server_init()'
 
212
    mysql_server_end() and then ends with a mysql_end().
122
213
*/
123
214
 
124
215
void my_thread_end(void)
125
216
{
 
217
  st_my_thread_var *tmp=
 
218
    static_cast<st_my_thread_var *>(pthread_getspecific(THR_KEY_mysys));
 
219
 
 
220
#ifdef EXTRA_DEBUG_THREADS
 
221
  fprintf(stderr,"my_thread_end(): tmp: 0x%lx  pthread_self: 0x%lx  thread_id: %ld\n",
 
222
          (long) tmp, (long) pthread_self(), tmp ? (long) tmp->id : 0L);
 
223
#endif
 
224
  if (tmp && tmp->init)
 
225
  {
 
226
#if !defined(__bsdi__) && !defined(__OpenBSD__)
 
227
 /* bsdi and openbsd 3.5 dumps core here */
 
228
    pthread_cond_destroy(&tmp->suspend);
 
229
#endif
 
230
    pthread_mutex_destroy(&tmp->mutex);
 
231
    free(tmp);
 
232
 
 
233
    /*
 
234
      Decrement counter for number of running threads. We are using this
 
235
      in my_thread_global_end() to wait until all threads have called
 
236
      my_thread_end and thus freed all memory they have allocated in
 
237
      my_thread_init()
 
238
    */
 
239
    pthread_mutex_lock(&THR_LOCK_threads);
 
240
    assert(THR_thread_count != 0);
 
241
    if (--THR_thread_count == 0)
 
242
      pthread_cond_signal(&THR_COND_threads);
 
243
    pthread_mutex_unlock(&THR_LOCK_threads);
 
244
  }
126
245
}
127
246
 
128
247
struct st_my_thread_var *_my_thread_var(void)
129
248
{
130
 
  return THR_KEY_mysys.get();
 
249
  struct st_my_thread_var *tmp= (struct st_my_thread_var*)pthread_getspecific(THR_KEY_mysys);
 
250
  return tmp;
 
251
}
 
252
 
 
253
static uint32_t get_thread_lib(void)
 
254
{
 
255
#ifdef _CS_GNU_LIBPTHREAD_VERSION
 
256
  char buff[64];
 
257
 
 
258
  confstr(_CS_GNU_LIBPTHREAD_VERSION, buff, sizeof(buff));
 
259
 
 
260
  if (!strncasecmp(buff, "NPTL", 4))
 
261
    return THD_LIB_NPTL;
 
262
  if (!strncasecmp(buff, "linuxthreads", 12))
 
263
    return THD_LIB_LT;
 
264
#endif
 
265
  return THD_LIB_OTHER;
131
266
}
132
267
 
133
268
} /* namespace internal */