← 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: Andrew Hutchings
  • Date: 2011-01-21 11:23:19 UTC
  • mto: (2100.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2101.
  • Revision ID: andrew@linuxjedi.co.uk-20110121112319-nj1cvg0yt3nnf2rr
https://launchpad.net/bugs/705771
Add errors page to drizzle client docs
Add link to specific error in migration docs
Minor changes to migration docs

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