← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/os0sync.h

  • Committer: Marisa Plumb
  • Date: 2010-12-04 02:38:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1984.
  • Revision ID: marisa.plumb@gmail.com-20101204023829-2khzxh30wxi256db
updates to a few sql docs 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/os0sync.h
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1995, 2009, Innobase Oy. All Rights Reserved.
4
 
Copyright (C) 2008, Google Inc.
 
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
 
4
Copyright (c) 2008, Google Inc.
5
5
 
6
6
Portions of this file contain modifications contributed and copyrighted by
7
7
Google, Inc. Those modifications are gratefully acknowledged and are described
38
38
#include "ut0lst.h"
39
39
 
40
40
#ifdef __WIN__
41
 
/** Native event (slow)*/
42
 
typedef HANDLE                  os_native_event_t;
 
41
 
43
42
/** Native mutex */
44
 
typedef CRITICAL_SECTION        os_fast_mutex_t;
45
 
/** Native condition variable. */
46
 
typedef CONDITION_VARIABLE      os_cond_t;
 
43
#define os_fast_mutex_t CRITICAL_SECTION
 
44
 
 
45
/** Native event */
 
46
typedef HANDLE          os_native_event_t;
 
47
 
 
48
/** Operating system event */
 
49
typedef struct os_event_struct  os_event_struct_t;
 
50
/** Operating system event handle */
 
51
typedef os_event_struct_t*      os_event_t;
 
52
 
 
53
/** An asynchronous signal sent between threads */
 
54
struct os_event_struct {
 
55
        os_native_event_t                 handle;
 
56
                                        /*!< Windows event */
 
57
        UT_LIST_NODE_T(os_event_struct_t) os_event_list;
 
58
                                        /*!< list of all created events */
 
59
};
47
60
#else
48
61
/** Native mutex */
49
 
typedef pthread_mutex_t         os_fast_mutex_t;
50
 
/** Native condition variable */
51
 
typedef pthread_cond_t          os_cond_t;
52
 
#endif
 
62
typedef pthread_mutex_t os_fast_mutex_t;
53
63
 
54
64
/** Operating system event */
55
65
typedef struct os_event_struct  os_event_struct_t;
58
68
 
59
69
/** An asynchronous signal sent between threads */
60
70
struct os_event_struct {
61
 
#ifdef __WIN__
62
 
        HANDLE          handle;         /*!< kernel event object, slow,
63
 
                                        used on older Windows */
64
 
#endif
65
71
        os_fast_mutex_t os_mutex;       /*!< this mutex protects the next
66
72
                                        fields */
67
73
        ibool           is_set;         /*!< this is TRUE when the event is
70
76
                                        this event */
71
77
        ib_int64_t      signal_count;   /*!< this is incremented each time
72
78
                                        the event becomes signaled */
73
 
        os_cond_t       cond_var;       /*!< condition variable is used in
 
79
        pthread_cond_t  cond_var;       /*!< condition variable is used in
74
80
                                        waiting for the event */
75
81
        UT_LIST_NODE_T(os_event_struct_t) os_event_list;
76
82
                                        /*!< list of all created events */
77
83
};
78
 
 
79
 
/** Denotes an infinite delay for os_event_wait_time() */
80
 
#define OS_SYNC_INFINITE_TIME   ULINT_UNDEFINED
81
 
 
82
 
/** Return value of os_event_wait_time() when the time is exceeded */
83
 
#define OS_SYNC_TIME_EXCEEDED   1
 
84
#endif
84
85
 
85
86
/** Operating system mutex */
86
87
typedef struct os_mutex_struct  os_mutex_str_t;
87
88
/** Operating system mutex handle */
88
89
typedef os_mutex_str_t*         os_mutex_t;
89
90
 
 
91
/** Denotes an infinite delay for os_event_wait_time() */
 
92
#define OS_SYNC_INFINITE_TIME   ((ulint)(-1))
 
93
 
 
94
/** Return value of os_event_wait_time() when the time is exceeded */
 
95
#define OS_SYNC_TIME_EXCEEDED   1
 
96
 
90
97
/** Mutex protecting counts and the event and OS 'slow' mutex lists */
91
98
extern os_mutex_t       os_sync_mutex;
92
99
 
179
186
                                        os_event_reset(). */
180
187
 
181
188
#define os_event_wait(event) os_event_wait_low(event, 0)
182
 
#define os_event_wait_time(e, t) os_event_wait_time_low(event, t, 0)
183
189
 
184
190
/**********************************************************//**
185
191
Waits for an event object until it is in the signaled state or
187
193
@return 0 if success, OS_SYNC_TIME_EXCEEDED if timeout was exceeded */
188
194
UNIV_INTERN
189
195
ulint
190
 
os_event_wait_time_low(
 
196
os_event_wait_time(
 
197
/*===============*/
 
198
        os_event_t      event,  /*!< in: event to wait */
 
199
        ulint           time);  /*!< in: timeout in microseconds, or
 
200
                                OS_SYNC_INFINITE_TIME */
 
201
#ifdef __WIN__
 
202
/**********************************************************//**
 
203
Waits for any event in an OS native event array. Returns if even a single
 
204
one is signaled or becomes signaled.
 
205
@return index of the event which was signaled */
 
206
UNIV_INTERN
 
207
ulint
 
208
os_event_wait_multiple(
191
209
/*===================*/
192
 
        os_event_t      event,                  /*!< in: event to wait */
193
 
        ulint           time_in_usec,           /*!< in: timeout in
194
 
                                                microseconds, or
195
 
                                                OS_SYNC_INFINITE_TIME */
196
 
        ib_int64_t      reset_sig_count);       /*!< in: zero or the value
197
 
                                                returned by previous call of
198
 
                                                os_event_reset(). */
 
210
        ulint                   n,      /*!< in: number of events in the
 
211
                                        array */
 
212
        os_native_event_t*      native_event_array);
 
213
                                        /*!< in: pointer to an array of event
 
214
                                        handles */
 
215
#endif
199
216
/*********************************************************//**
200
217
Creates an operating system mutex semaphore. Because these are slow, the
201
218
mutex semaphore of InnoDB itself (mutex_t) should be used where possible.
202
219
@return the mutex handle */
203
220
UNIV_INTERN
204
221
os_mutex_t
205
 
os_mutex_create(void);
206
 
/*=================*/
 
222
os_mutex_create(
 
223
/*============*/
 
224
        const char*     name);  /*!< in: the name of the mutex, if NULL
 
225
                                the mutex is created without a name */
207
226
/**********************************************************//**
208
227
Acquires ownership of a mutex semaphore. */
209
228
UNIV_INTERN
311
330
Returns the old value of *ptr, atomically sets *ptr to new_val */
312
331
 
313
332
# define os_atomic_test_and_set_byte(ptr, new_val) \
314
 
        __sync_lock_test_and_set(ptr, (byte) new_val)
 
333
        __sync_lock_test_and_set(ptr, new_val)
315
334
 
316
335
#elif defined(HAVE_SOLARIS_ATOMICS)
317
336