← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/os/os0sync.c

  • Committer: Monty Taylor
  • Date: 2009-04-14 19:16:51 UTC
  • mto: (997.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 994.
  • Revision ID: mordred@inaugust.com-20090414191651-ltbww6hpqks8k7qk
Clarified instructions in README.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/os/os0sync.c
16
16
 
17
17
*****************************************************************************/
18
18
 
19
 
/**************************************************//**
20
 
@file os/os0sync.c
 
19
/******************************************************
21
20
The interface to the operating system
22
21
synchronization primitives.
23
22
 
35
34
 
36
35
#include "ut0mem.h"
37
36
#include "srv0start.h"
38
 
#include "ha_prototypes.h"
39
37
 
40
38
/* Type definition for an operating system mutex struct */
41
39
struct os_mutex_struct{
42
 
        os_event_t      event;  /*!< Used by sync0arr.c for queing threads */
43
 
        void*           handle; /*!< OS handle to mutex */
44
 
        ulint           count;  /*!< we use this counter to check
 
40
        os_event_t      event;  /* Used by sync0arr.c for queing threads */
 
41
        void*           handle; /* OS handle to mutex */
 
42
        ulint           count;  /* we use this counter to check
45
43
                                that the same thread does not
46
44
                                recursively lock the mutex: we
47
45
                                do not assume that the OS mutex
51
49
                                /* list of all 'slow' OS mutexes created */
52
50
};
53
51
 
54
 
/** Mutex protecting counts and the lists of OS mutexes and events */
 
52
/* Mutex protecting counts and the lists of OS mutexes and events */
55
53
UNIV_INTERN os_mutex_t  os_sync_mutex;
56
 
/** TRUE if os_sync_mutex has been initialized */
57
54
static ibool            os_sync_mutex_inited    = FALSE;
58
 
/** TRUE when os_sync_free() is being executed */
59
55
static ibool            os_sync_free_called     = FALSE;
60
56
 
61
 
/** This is incremented by 1 in os_thread_create and decremented by 1 in
 
57
/* This is incremented by 1 in os_thread_create and decremented by 1 in
62
58
os_thread_exit */
63
59
UNIV_INTERN ulint       os_thread_count         = 0;
64
60
 
65
 
/** The list of all events created */
 
61
/* The list of all events created */
66
62
static UT_LIST_BASE_NODE_T(os_event_struct_t)   os_event_list;
67
63
 
68
 
/** The list of all OS 'slow' mutexes */
 
64
/* The list of all OS 'slow' mutexes */
69
65
static UT_LIST_BASE_NODE_T(os_mutex_str_t)      os_mutex_list;
70
66
 
71
67
UNIV_INTERN ulint       os_event_count          = 0;
77
73
This version of the free event function doesn't acquire the global lock */
78
74
static void os_event_free_internal(os_event_t   event);
79
75
 
80
 
/*********************************************************//**
 
76
/*************************************************************
81
77
Initializes global event and OS 'slow' mutex lists. */
82
78
UNIV_INTERN
83
79
void
92
88
        os_sync_mutex_inited = TRUE;
93
89
}
94
90
 
95
 
/*********************************************************//**
 
91
/*************************************************************
96
92
Frees created events and OS 'slow' mutexes. */
97
93
UNIV_INTERN
98
94
void
129
125
        os_sync_free_called = FALSE;
130
126
}
131
127
 
132
 
/*********************************************************//**
 
128
/*************************************************************
133
129
Creates an event semaphore, i.e., a semaphore which may just have two
134
130
states: signaled and nonsignaled. The created event is manual reset: it
135
 
must be reset explicitly by calling sync_os_reset_event.
136
 
@return the event handle */
 
131
must be reset explicitly by calling sync_os_reset_event. */
137
132
UNIV_INTERN
138
133
os_event_t
139
134
os_event_create(
140
135
/*============*/
141
 
        const char*     name)   /*!< in: the name of the event, if NULL
 
136
                                /* out: the event handle */
 
137
        const char*     name)   /* in: the name of the event, if NULL
142
138
                                the event is created without a name */
143
139
{
144
140
#ifdef __WIN__
165
161
 
166
162
        os_fast_mutex_init(&(event->os_mutex));
167
163
 
 
164
#if defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10)
 
165
        ut_a(0 == pthread_cond_init(&(event->cond_var),
 
166
                                    pthread_condattr_default));
 
167
#else
168
168
        ut_a(0 == pthread_cond_init(&(event->cond_var), NULL));
169
 
 
 
169
#endif
170
170
        event->is_set = FALSE;
171
171
 
172
172
        /* We return this value in os_event_reset(), which can then be
197
197
        return(event);
198
198
}
199
199
 
200
 
/**********************************************************//**
 
200
#ifdef __WIN__
 
201
/*************************************************************
 
202
Creates an auto-reset event semaphore, i.e., an event which is automatically
 
203
reset when a single thread is released. Works only in Windows. */
 
204
UNIV_INTERN
 
205
os_event_t
 
206
os_event_create_auto(
 
207
/*=================*/
 
208
                                /* out: the event handle */
 
209
        const char*     name)   /* in: the name of the event, if NULL
 
210
                                the event is created without a name */
 
211
{
 
212
        os_event_t event;
 
213
 
 
214
        event = ut_malloc(sizeof(struct os_event_struct));
 
215
 
 
216
        event->handle = CreateEvent(NULL, /* No security attributes */
 
217
                                    FALSE, /* Auto-reset */
 
218
                                    FALSE, /* Initial state nonsignaled */
 
219
                                    (LPCTSTR) name);
 
220
 
 
221
        if (!event->handle) {
 
222
                fprintf(stderr,
 
223
                        "InnoDB: Could not create a Windows auto"
 
224
                        " event semaphore; Windows error %lu\n",
 
225
                        (ulong) GetLastError());
 
226
        }
 
227
 
 
228
        /* Put to the list of events */
 
229
        os_mutex_enter(os_sync_mutex);
 
230
 
 
231
        UT_LIST_ADD_FIRST(os_event_list, os_event_list, event);
 
232
 
 
233
        os_event_count++;
 
234
 
 
235
        os_mutex_exit(os_sync_mutex);
 
236
 
 
237
        return(event);
 
238
}
 
239
#endif
 
240
 
 
241
/**************************************************************
201
242
Sets an event semaphore to the signaled state: lets waiting threads
202
243
proceed. */
203
244
UNIV_INTERN
204
245
void
205
246
os_event_set(
206
247
/*=========*/
207
 
        os_event_t      event)  /*!< in: event to set */
 
248
        os_event_t      event)  /* in: event to set */
208
249
{
209
250
#ifdef __WIN__
210
251
        ut_a(event);
226
267
#endif
227
268
}
228
269
 
229
 
/**********************************************************//**
 
270
/**************************************************************
230
271
Resets an event semaphore to the nonsignaled state. Waiting threads will
231
272
stop to wait for the event.
232
273
The return value should be passed to os_even_wait_low() if it is desired
233
274
that this thread should not wait in case of an intervening call to
234
275
os_event_set() between this os_event_reset() and the
235
 
os_event_wait_low() call. See comments for os_event_wait_low().
236
 
@return current signal_count. */
 
276
os_event_wait_low() call. See comments for os_event_wait_low(). */
237
277
UNIV_INTERN
238
278
ib_int64_t
239
279
os_event_reset(
240
280
/*===========*/
241
 
        os_event_t      event)  /*!< in: event to reset */
 
281
                                /* out: current signal_count. */
 
282
        os_event_t      event)  /* in: event to reset */
242
283
{
243
284
        ib_int64_t      ret = 0;
244
285
 
263
304
        return(ret);
264
305
}
265
306
 
266
 
/**********************************************************//**
 
307
/**************************************************************
267
308
Frees an event object, without acquiring the global lock. */
268
309
static
269
310
void
270
311
os_event_free_internal(
271
312
/*===================*/
272
 
        os_event_t      event)  /*!< in: event to free */
 
313
        os_event_t      event)  /* in: event to free */
273
314
{
274
315
#ifdef __WIN__
275
316
        ut_a(event);
292
333
        ut_free(event);
293
334
}
294
335
 
295
 
/**********************************************************//**
 
336
/**************************************************************
296
337
Frees an event object. */
297
338
UNIV_INTERN
298
339
void
299
340
os_event_free(
300
341
/*==========*/
301
 
        os_event_t      event)  /*!< in: event to free */
 
342
        os_event_t      event)  /* in: event to free */
302
343
 
303
344
{
304
345
#ifdef __WIN__
324
365
        ut_free(event);
325
366
}
326
367
 
327
 
/**********************************************************//**
 
368
/**************************************************************
328
369
Waits for an event object until it is in the signaled state. If
329
370
srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS this also exits the
330
371
waiting thread when the event becomes signaled (or immediately if the
348
389
void
349
390
os_event_wait_low(
350
391
/*==============*/
351
 
        os_event_t      event,          /*!< in: event to wait */
352
 
        ib_int64_t      reset_sig_count)/*!< in: zero or the value
 
392
        os_event_t      event,          /* in: event to wait */
 
393
        ib_int64_t      reset_sig_count)/* in: zero or the value
353
394
                                        returned by previous call of
354
395
                                        os_event_reset(). */
355
396
{
403
444
#endif
404
445
}
405
446
 
406
 
/**********************************************************//**
 
447
/**************************************************************
407
448
Waits for an event object until it is in the signaled state or
408
 
a timeout is exceeded. In Unix the timeout is always infinite.
409
 
@return 0 if success, OS_SYNC_TIME_EXCEEDED if timeout was exceeded */
 
449
a timeout is exceeded. In Unix the timeout is always infinite. */
410
450
UNIV_INTERN
411
451
ulint
412
452
os_event_wait_time(
413
453
/*===============*/
414
 
        os_event_t      event,  /*!< in: event to wait */
415
 
        ulint           time)   /*!< in: timeout in microseconds, or
 
454
                                /* out: 0 if success, OS_SYNC_TIME_EXCEEDED if
 
455
                                timeout was exceeded */
 
456
        os_event_t      event,  /* in: event to wait */
 
457
        ulint           time)   /* in: timeout in microseconds, or
416
458
                                OS_SYNC_INFINITE_TIME */
417
459
{
418
460
#ifdef __WIN__
448
490
}
449
491
 
450
492
#ifdef __WIN__
451
 
/**********************************************************//**
 
493
/**************************************************************
452
494
Waits for any event in an OS native event array. Returns if even a single
453
 
one is signaled or becomes signaled.
454
 
@return index of the event which was signaled */
 
495
one is signaled or becomes signaled. */
455
496
UNIV_INTERN
456
497
ulint
457
498
os_event_wait_multiple(
458
499
/*===================*/
459
 
        ulint                   n,      /*!< in: number of events in the
 
500
                                        /* out: index of the event
 
501
                                        which was signaled */
 
502
        ulint                   n,      /* in: number of events in the
460
503
                                        array */
461
504
        os_native_event_t*      native_event_array)
462
 
                                        /*!< in: pointer to an array of event
 
505
                                        /* in: pointer to an array of event
463
506
                                        handles */
464
507
{
465
508
        DWORD   index;
471
514
                                       FALSE,      /* Wait for any 1 event */
472
515
                                       INFINITE); /* Infinite wait time
473
516
                                                  limit */
474
 
        ut_a(index >= WAIT_OBJECT_0);   /* NOTE: Pointless comparison */
 
517
        ut_a(index >= WAIT_OBJECT_0);   /* NOTE: Pointless comparision */
475
518
        ut_a(index < WAIT_OBJECT_0 + n);
476
519
 
477
520
        if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {
482
525
}
483
526
#endif
484
527
 
485
 
/*********************************************************//**
 
528
/*************************************************************
486
529
Creates an operating system mutex semaphore. Because these are slow, the
487
 
mutex semaphore of InnoDB itself (mutex_t) should be used where possible.
488
 
@return the mutex handle */
 
530
mutex semaphore of InnoDB itself (mutex_t) should be used where possible. */
489
531
UNIV_INTERN
490
532
os_mutex_t
491
533
os_mutex_create(
492
534
/*============*/
493
 
        const char*     name)   /*!< in: the name of the mutex, if NULL
 
535
                                /* out: the mutex handle */
 
536
        const char*     name)   /* in: the name of the mutex, if NULL
494
537
                                the mutex is created without a name */
495
538
{
496
539
#ifdef __WIN__
533
576
        return(mutex_str);
534
577
}
535
578
 
536
 
/**********************************************************//**
 
579
/**************************************************************
537
580
Acquires ownership of a mutex semaphore. */
538
581
UNIV_INTERN
539
582
void
540
583
os_mutex_enter(
541
584
/*===========*/
542
 
        os_mutex_t      mutex)  /*!< in: mutex to acquire */
 
585
        os_mutex_t      mutex)  /* in: mutex to acquire */
543
586
{
544
587
#ifdef __WIN__
545
588
        DWORD   err;
562
605
#endif
563
606
}
564
607
 
565
 
/**********************************************************//**
 
608
/**************************************************************
566
609
Releases ownership of a mutex. */
567
610
UNIV_INTERN
568
611
void
569
612
os_mutex_exit(
570
613
/*==========*/
571
 
        os_mutex_t      mutex)  /*!< in: mutex to release */
 
614
        os_mutex_t      mutex)  /* in: mutex to release */
572
615
{
573
616
        ut_a(mutex);
574
617
 
582
625
#endif
583
626
}
584
627
 
585
 
/**********************************************************//**
 
628
/**************************************************************
586
629
Frees a mutex object. */
587
630
UNIV_INTERN
588
631
void
589
632
os_mutex_free(
590
633
/*==========*/
591
 
        os_mutex_t      mutex)  /*!< in: mutex to free */
 
634
        os_mutex_t      mutex)  /* in: mutex to free */
592
635
{
593
636
        ut_a(mutex);
594
637
 
619
662
#endif
620
663
}
621
664
 
622
 
/*********************************************************//**
 
665
/*************************************************************
623
666
Initializes an operating system fast mutex semaphore. */
624
667
UNIV_INTERN
625
668
void
626
669
os_fast_mutex_init(
627
670
/*===============*/
628
 
        os_fast_mutex_t*        fast_mutex)     /*!< in: fast mutex */
 
671
        os_fast_mutex_t*        fast_mutex)     /* in: fast mutex */
629
672
{
630
673
#ifdef __WIN__
631
674
        ut_a(fast_mutex);
632
675
 
633
676
        InitializeCriticalSection((LPCRITICAL_SECTION) fast_mutex);
634
677
#else
635
 
        ut_a(0 == innobase_fast_mutex_init(fast_mutex));
 
678
#if defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10)
 
679
        ut_a(0 == pthread_mutex_init(fast_mutex, pthread_mutexattr_default));
 
680
#else
 
681
        ut_a(0 == pthread_mutex_init(fast_mutex, MY_MUTEX_INIT_FAST));
 
682
#endif
636
683
#endif
637
684
        if (UNIV_LIKELY(os_sync_mutex_inited)) {
638
685
                /* When creating os_sync_mutex itself (in Unix) we cannot
648
695
        }
649
696
}
650
697
 
651
 
/**********************************************************//**
 
698
/**************************************************************
652
699
Acquires ownership of a fast mutex. */
653
700
UNIV_INTERN
654
701
void
655
702
os_fast_mutex_lock(
656
703
/*===============*/
657
 
        os_fast_mutex_t*        fast_mutex)     /*!< in: mutex to acquire */
 
704
        os_fast_mutex_t*        fast_mutex)     /* in: mutex to acquire */
658
705
{
659
706
#ifdef __WIN__
660
707
        EnterCriticalSection((LPCRITICAL_SECTION) fast_mutex);
663
710
#endif
664
711
}
665
712
 
666
 
/**********************************************************//**
 
713
/**************************************************************
667
714
Releases ownership of a fast mutex. */
668
715
UNIV_INTERN
669
716
void
670
717
os_fast_mutex_unlock(
671
718
/*=================*/
672
 
        os_fast_mutex_t*        fast_mutex)     /*!< in: mutex to release */
 
719
        os_fast_mutex_t*        fast_mutex)     /* in: mutex to release */
673
720
{
674
721
#ifdef __WIN__
675
722
        LeaveCriticalSection(fast_mutex);
678
725
#endif
679
726
}
680
727
 
681
 
/**********************************************************//**
 
728
/**************************************************************
682
729
Frees a mutex object. */
683
730
UNIV_INTERN
684
731
void
685
732
os_fast_mutex_free(
686
733
/*===============*/
687
 
        os_fast_mutex_t*        fast_mutex)     /*!< in: mutex to free */
 
734
        os_fast_mutex_t*        fast_mutex)     /* in: mutex to free */
688
735
{
689
736
#ifdef __WIN__
690
737
        ut_a(fast_mutex);