← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/os/os0thread.c

  • Committer: Eric Day
  • Date: 2009-10-31 21:53:33 UTC
  • mfrom: (1200 staging)
  • mto: This revision was merged to the branch mainline in revision 1202.
  • Revision ID: eday@oddments.org-20091031215333-j94bjoanwmi68p6f
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/os/os0thread.c
16
16
 
17
17
*****************************************************************************/
18
18
 
19
 
/******************************************************
 
19
/**************************************************//**
 
20
@file os/os0thread.c
20
21
The interface to the operating system thread control primitives
21
22
 
22
23
Created 9/8/1995 Heikki Tuuri
31
32
#include <windows.h>
32
33
#endif
33
34
 
 
35
#ifndef UNIV_HOTBACKUP
34
36
#include "srv0srv.h"
35
37
#include "os0sync.h"
36
38
 
37
 
/*******************************************************************
38
 
Compares two thread ids for equality. */
 
39
/***************************************************************//**
 
40
Compares two thread ids for equality.
 
41
@return TRUE if equal */
39
42
UNIV_INTERN
40
43
ibool
41
44
os_thread_eq(
42
45
/*=========*/
43
 
                                /* out: TRUE if equal */
44
 
        os_thread_id_t  a,      /* in: OS thread or thread id */
45
 
        os_thread_id_t  b)      /* in: OS thread or thread id */
 
46
        os_thread_id_t  a,      /*!< in: OS thread or thread id */
 
47
        os_thread_id_t  b)      /*!< in: OS thread or thread id */
46
48
{
47
49
#ifdef __WIN__
48
50
        if (a == b) {
59
61
#endif
60
62
}
61
63
 
62
 
/********************************************************************
 
64
/****************************************************************//**
63
65
Converts an OS thread id to a ulint. It is NOT guaranteed that the ulint is
64
 
unique for the thread though! */
 
66
unique for the thread though!
 
67
@return thread identifier as a number */
65
68
UNIV_INTERN
66
69
ulint
67
70
os_thread_pf(
68
71
/*=========*/
69
 
        os_thread_id_t  a)
 
72
        os_thread_id_t  a)      /*!< in: OS thread identifier */
70
73
{
71
74
#ifdef UNIV_HPUX10
72
75
        /* In HP-UX-10.20 a pthread_t is a struct of 3 fields: field1, field2,
78
81
#endif
79
82
}
80
83
 
81
 
/*********************************************************************
 
84
/*****************************************************************//**
82
85
Returns the thread identifier of current thread. Currently the thread
83
86
identifier in Unix is the thread handle itself. Note that in HP-UX
84
 
pthread_t is a struct of 3 fields. */
 
87
pthread_t is a struct of 3 fields.
 
88
@return current thread identifier */
85
89
UNIV_INTERN
86
90
os_thread_id_t
87
91
os_thread_get_curr_id(void)
94
98
#endif
95
99
}
96
100
 
97
 
/********************************************************************
 
101
/****************************************************************//**
98
102
Creates a new thread of execution. The execution starts from
99
103
the function given. The start function takes a void* parameter
100
 
and returns an ulint. */
 
104
and returns an ulint.
 
105
@return handle to the thread */
101
106
UNIV_INTERN
102
107
os_thread_t
103
108
os_thread_create(
104
109
/*=============*/
105
 
                                                /* out: handle to the thread */
106
110
#ifndef __WIN__
107
111
        os_posix_f_t            start_f,
108
112
#else
109
 
        ulint (*start_f)(void*),                /* in: pointer to function
 
113
        ulint (*start_f)(void*),                /*!< in: pointer to function
110
114
                                                from which to start */
111
115
#endif
112
 
        void*                   arg,            /* in: argument to start
 
116
        void*                   arg,            /*!< in: argument to start
113
117
                                                function */
114
 
        os_thread_id_t*         thread_id)      /* out: id of the created
 
118
        os_thread_id_t*         thread_id)      /*!< out: id of the created
115
119
                                                thread, or NULL */
116
120
{
117
121
#ifdef __WIN__
148
152
        os_thread_t     pthread;
149
153
        pthread_attr_t  attr;
150
154
 
151
 
#if !(defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10))
 
155
#ifndef UNIV_HPUX10
152
156
        pthread_attr_init(&attr);
153
157
#endif
154
158
 
182
186
        os_thread_count++;
183
187
        os_mutex_exit(os_sync_mutex);
184
188
 
185
 
#if defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10)
 
189
#ifdef UNIV_HPUX10
186
190
        ret = pthread_create(&pthread, pthread_attr_default, start_f, arg);
187
191
#else
188
192
        ret = pthread_create(&pthread, &attr, start_f, arg);
193
197
                exit(1);
194
198
        }
195
199
 
196
 
#if !(defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10))
 
200
#ifndef UNIV_HPUX10
197
201
        pthread_attr_destroy(&attr);
198
202
#endif
199
203
        if (srv_set_thread_priorities) {
213
217
#endif
214
218
}
215
219
 
216
 
/*********************************************************************
 
220
/*****************************************************************//**
217
221
Exits the current thread. */
218
222
UNIV_INTERN
219
223
void
220
224
os_thread_exit(
221
225
/*===========*/
222
 
        void*   exit_value)     /* in: exit value; in Windows this void*
 
226
        void*   exit_value)     /*!< in: exit value; in Windows this void*
223
227
                                is cast as a DWORD */
224
228
{
225
229
#ifdef UNIV_DEBUG_THREAD_CREATION
237
241
#endif
238
242
}
239
243
 
240
 
/*********************************************************************
241
 
Returns handle to the current thread. */
 
244
/*****************************************************************//**
 
245
Returns handle to the current thread.
 
246
@return current thread handle */
242
247
UNIV_INTERN
243
248
os_thread_t
244
249
os_thread_get_curr(void)
251
256
#endif
252
257
}
253
258
 
254
 
/*********************************************************************
 
259
/*****************************************************************//**
255
260
Advises the os to give up remainder of the thread's time slice. */
256
261
UNIV_INTERN
257
262
void
270
275
        os_thread_sleep(0);
271
276
#endif
272
277
}
 
278
#endif /* !UNIV_HOTBACKUP */
273
279
 
274
 
/*********************************************************************
 
280
/*****************************************************************//**
275
281
The thread sleeps at least the time given in microseconds. */
276
282
UNIV_INTERN
277
283
void
278
284
os_thread_sleep(
279
285
/*============*/
280
 
        ulint   tm)     /* in: time in microseconds */
 
286
        ulint   tm)     /*!< in: time in microseconds */
281
287
{
282
288
#ifdef __WIN__
283
289
        Sleep((DWORD) tm / 1000);
293
299
#endif
294
300
}
295
301
 
296
 
/**********************************************************************
 
302
#ifndef UNIV_HOTBACKUP
 
303
/******************************************************************//**
297
304
Sets a thread priority. */
298
305
UNIV_INTERN
299
306
void
300
307
os_thread_set_priority(
301
308
/*===================*/
302
 
        os_thread_t     handle, /* in: OS handle to the thread */
303
 
        ulint           pri)    /* in: priority */
 
309
        os_thread_t     handle, /*!< in: OS handle to the thread */
 
310
        ulint           pri)    /*!< in: priority */
304
311
{
305
312
#ifdef __WIN__
306
313
        int     os_pri;
322
329
#endif
323
330
}
324
331
 
325
 
/**********************************************************************
326
 
Gets a thread priority. */
 
332
/******************************************************************//**
 
333
Gets a thread priority.
 
334
@return priority */
327
335
UNIV_INTERN
328
336
ulint
329
337
os_thread_get_priority(
330
338
/*===================*/
331
 
                                /* out: priority */
332
339
        os_thread_t     handle __attribute__((unused)))
333
 
                                /* in: OS handle to the thread */
 
340
                                /*!< in: OS handle to the thread */
334
341
{
335
342
#ifdef __WIN__
336
343
        int     os_pri;
354
361
#endif
355
362
}
356
363
 
357
 
/**********************************************************************
358
 
Gets the last operating system error code for the calling thread. */
 
364
/******************************************************************//**
 
365
Gets the last operating system error code for the calling thread.
 
366
@return last error on Windows, 0 otherwise */
359
367
UNIV_INTERN
360
368
ulint
361
369
os_thread_get_last_error(void)
367
375
        return(0);
368
376
#endif
369
377
}
 
378
#endif /* !UNIV_HOTBACKUP */