← Back to branch summary

~vkolesnikov/pbxt/pbxt-preload-test-bug

« back to all changes in this revision

Viewing changes to src/lock_xt.h

  • Committer: Vladimir Kolesnikov
  • Date: 2009-01-21 13:55:57 UTC
  • mto: This revision was merged to the branch mainline in revision 533.
  • Revision ID: vladimir@primebase.org-20090121135557-gyzk4wo3kj126jda
added thread lock lists

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lock_xt.h
27
27
 
28
28
#include "xt_defs.h"
29
29
#include "util_xt.h"
 
30
#include "locklist_xt.h"
 
31
#include "pthread_xt.h"
30
32
 
31
33
struct XTThread;
32
34
struct XTDatabase;
135
137
        struct XTThread                         *xs_lock_thread;
136
138
        u_int                                           xs_inited;
137
139
#endif
 
140
#ifdef XT_THREAD_LOCK_INFO
 
141
        XTThreadLockInfoRec                     xs_lock_info;
 
142
        const char                                  *xs_name;
 
143
#endif
138
144
        xt_mutex_type                           xs_lock;
139
145
        xt_cond_type                            xs_cond;
140
146
        volatile xtWord4                        xs_state;
149
155
        }                                                       x;
150
156
} XTRWMutexRec, *XTRWMutexPtr;
151
157
 
 
158
#ifdef XT_THREAD_LOCK_INFO
 
159
#define xt_rwmutex_init_with_autoname(a,b) xt_rwmutex_init(a,b,LOCKLIST_ARG_SUFFIX(b))
 
160
void xt_rwmutex_init(struct XTThread *self, XTRWMutexPtr xsl, const char *name);
 
161
#else
 
162
#define xt_rwmutex_init_with_autoname(a,b) xt_rwmutex_init(a,b)
152
163
void xt_rwmutex_init(struct XTThread *self, XTRWMutexPtr xsl);
 
164
#endif
153
165
void xt_rwmutex_free(struct XTThread *self, XTRWMutexPtr xsl);
154
166
xtBool xt_rwmutex_xlock(XTRWMutexPtr xsl, xtThreadID thd_id);
155
167
xtBool xt_rwmutex_slock(XTRWMutexPtr xsl, xtThreadID thd_id);
184
196
#ifdef DEBUG
185
197
        struct XTThread                         *spl_locker;
186
198
#endif
 
199
#ifdef XT_THREAD_LOCK_INFO
 
200
        XTThreadLockInfoRec                     spl_lock_info;
 
201
        const char                                  *spl_name;
 
202
#endif
187
203
} XTSpinLockRec, *XTSpinLockPtr;
188
204
 
 
205
#ifdef XT_THREAD_LOCK_INFO
 
206
#define xt_spinlock_init_with_autoname(a,b) xt_spinlock_init(a,b,LOCKLIST_ARG_SUFFIX(b))
 
207
void    xt_spinlock_init(struct XTThread *self, XTSpinLockPtr sp, const char *name);
 
208
#else
 
209
#define xt_spinlock_init_with_autoname(a,b) xt_spinlock_init(a,b)
189
210
void    xt_spinlock_init(struct XTThread *self, XTSpinLockPtr sp);
 
211
#endif
190
212
void    xt_spinlock_free(struct XTThread *self, XTSpinLockPtr sp);
191
213
xtBool  xt_spinlock_spin(XTSpinLockPtr spl);
192
214
#ifdef DEBUG
345
367
 */
346
368
inline xtBool xt_spinlock_lock(XTSpinLockPtr spl)
347
369
{
348
 
        if (!xt_spinlock_set(spl))
 
370
        if (!xt_spinlock_set(spl)) {
 
371
#ifdef XT_THREAD_LOCK_INFO
 
372
                xt_thread_lock_info_add_owner(&spl->spl_lock_info);
 
373
#endif
349
374
                return OK;
 
375
        }
 
376
#ifdef XT_THREAD_LOCK_INFO
 
377
        xtBool spin_result = xt_spinlock_spin(spl);
 
378
        if (spin_result)
 
379
                xt_thread_lock_info_add_owner(&spl->spl_lock_info);
 
380
        return spin_result;
 
381
#else
350
382
        return xt_spinlock_spin(spl);
 
383
#endif
351
384
}
352
385
 
353
386
inline void xt_spinlock_unlock(XTSpinLockPtr spl)
354
387
{
355
388
        xt_spinlock_reset(spl);
 
389
#ifdef XT_THREAD_LOCK_INFO
 
390
        xt_thread_lock_info_release_owner(&spl->spl_lock_info);
 
391
#endif
356
392
}
357
393
 
358
394
void xt_unit_test_read_write_locks(struct XTThread *self);
370
406
        u_int                                           fal_wait_wakeup;
371
407
        u_int                                           fal_wait_alloc;
372
408
        struct XTThread                         *fal_wait_list[XT_FAST_LOCK_MAX_WAIT];
 
409
#ifdef XT_THREAD_LOCK_INFO
 
410
        XTThreadLockInfoRec                     fal_lock_info;
 
411
        const char                                  *fal_name;
 
412
#endif
373
413
} XTFastLockRec, *XTFastLockPtr;
374
414
 
 
415
#ifdef XT_THREAD_LOCK_INFO
 
416
#define xt_fastlock_init_with_autoname(a,b) xt_fastlock_init(a,b,LOCKLIST_ARG_SUFFIX(b))
 
417
void    xt_fastlock_init(struct XTThread *self, XTFastLockPtr spl, const char *name);
 
418
#else
 
419
#define xt_fastlock_init_with_autoname(a,b) xt_fastlock_init(a,b)
375
420
void    xt_fastlock_init(struct XTThread *self, XTFastLockPtr spl);
 
421
#endif
376
422
void    xt_fastlock_free(struct XTThread *self, XTFastLockPtr spl);
377
423
void    xt_fastlock_wakeup(XTFastLockPtr spl);
378
424
xtBool  xt_fastlock_spin(XTFastLockPtr spl, struct XTThread *thread);
381
427
{
382
428
        if (!xt_spinlock_set(&fal->fal_spinlock)) {
383
429
                fal->fal_locker = thread;
 
430
#ifdef XT_THREAD_LOCK_INFO
 
431
        xt_thread_lock_info_add_owner(&fal->fal_lock_info);
 
432
#endif
384
433
                return OK;
385
434
        }
 
435
#ifdef XT_THREAD_LOCK_INFO
 
436
        xtBool spin_result = xt_fastlock_spin(fal, thread);
 
437
        if (spin_result)
 
438
                xt_thread_lock_info_add_owner(&fal->fal_lock_info);
 
439
        return spin_result;
 
440
#else
386
441
        return xt_fastlock_spin(fal, thread);
 
442
#endif
387
443
}
388
444
 
389
445
inline void xt_fastlock_unlock(XTFastLockPtr fal, struct XTThread *thread __attribute__((unused)))
394
450
                fal->fal_locker = NULL;
395
451
                xt_spinlock_reset(&fal->fal_spinlock);
396
452
        }
 
453
#ifdef XT_THREAD_LOCK_INFO
 
454
        xt_thread_lock_info_release_owner(&fal->fal_lock_info);
 
455
#endif
397
456
}
398
457
 
399
458
typedef struct XTSpinRWLock {
409
468
#endif
410
469
                volatile  xtWord1               *srw_rlock;
411
470
        } x;
 
471
 
 
472
#ifdef XT_THREAD_LOCK_INFO
 
473
        XTThreadLockInfoRec                     srw_lock_info;
 
474
        const char                                  *srw_name;
 
475
#endif
 
476
 
412
477
} XTSpinRWLockRec, *XTSpinRWLockPtr;
413
478
 
 
479
#ifdef XT_THREAD_LOCK_INFO
 
480
#define xt_spinrwlock_init_with_autoname(a,b) xt_spinrwlock_init(a,b,LOCKLIST_ARG_SUFFIX(b))
 
481
void xt_spinrwlock_init(struct XTThread *self, XTSpinRWLockPtr xsl, const char *name);
 
482
#else
 
483
#define xt_spinrwlock_init_with_autoname(a,b) xt_spinrwlock_init(a,b)
414
484
void xt_spinrwlock_init(struct XTThread *self, XTSpinRWLockPtr xsl);
 
485
#endif
415
486
void xt_spinrwlock_free(struct XTThread *self, XTSpinRWLockPtr xsl);
416
487
xtBool xt_spinrwlock_xlock(XTSpinRWLockPtr xsl, xtThreadID thd_id);
417
488
xtBool xt_spinrwlock_slock(XTSpinRWLockPtr xsl, xtThreadID thd_id);
431
502
#endif
432
503
                volatile  xtWord1               *frw_rlock;
433
504
        } x;
 
505
 
 
506
#ifdef XT_THREAD_LOCK_INFO
 
507
        XTThreadLockInfoRec                     frw_lock_info;
 
508
        const char                                  *frw_name;
 
509
#endif
 
510
 
434
511
} XTFastRWLockRec, *XTFastRWLockPtr;
435
512
 
 
513
#ifdef XT_THREAD_LOCK_INFO
 
514
#define xt_fastrwlock_init_with_autoname(a,b) xt_fastrwlock_init(a,b,LOCKLIST_ARG_SUFFIX(b))
 
515
void xt_fastrwlock_init(struct XTThread *self, XTFastRWLockPtr frw, const char *name);
 
516
#else
 
517
#define xt_fastrwlock_init_with_autoname(a,b) xt_fastrwlock_init(a,b)
436
518
void xt_fastrwlock_init(struct XTThread *self, XTFastRWLockPtr frw);
 
519
#endif
 
520
 
437
521
void xt_fastrwlock_free(struct XTThread *self, XTFastRWLockPtr frw);
438
522
xtBool xt_fastrwlock_xlock(XTFastRWLockPtr frw, struct XTThread *thread);
439
523
xtBool xt_fastrwlock_slock(XTFastRWLockPtr frw, struct XTThread *thread);