1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
/** @file
A brief file description
@section license License
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef _ink_mutex_h_
#define _ink_mutex_h_
/***********************************************************************
Fast Mutex
Uses atomic memory operations to minimize blocking.
***********************************************************************/
#include <stdio.h>
#include "ink_port.h"
#if defined(POSIX_THREAD)
#include <pthread.h>
#include <stdlib.h>
typedef pthread_mutex_t ProcessMutex;
typedef ProcessMutex ink_mutex;
typedef ProcessMutex InkMutex;
// just a wrapper so that the constructor gets executed
// before the first call to ink_mutex_init();
class x_pthread_mutexattr_t
{
public:
pthread_mutexattr_t attr;
x_pthread_mutexattr_t();
~x_pthread_mutexattr_t()
{
}
};
inline
x_pthread_mutexattr_t::x_pthread_mutexattr_t()
{
pthread_mutexattr_init(&attr);
#ifndef POSIX_THREAD_10031c
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
#endif
}
extern class x_pthread_mutexattr_t _g_mattr;
static inline int
ink_mutex_init(ink_mutex * m, const char *name)
{
(void) name;
#if defined(solaris)
if ( pthread_mutex_init(m, NULL) != 0 ) {
abort();
}
#else
if (pthread_mutex_init(m, &_g_mattr.attr) != 0) {
abort();
}
#endif
return 0;
}
static inline int
ink_mutex_destroy(ink_mutex * m)
{
return pthread_mutex_destroy(m);
}
static inline int
ink_mutex_acquire(ink_mutex * m)
{
if (pthread_mutex_lock(m) != 0) {
abort();
}
return 0;
}
static inline int
ink_mutex_release(ink_mutex * m)
{
if (pthread_mutex_unlock(m) != 0) {
abort();
}
return 0;
}
static inline int
ink_mutex_try_acquire(ink_mutex * m)
{
return pthread_mutex_trylock(m) == 0;
}
#endif /* #if defined(POSIX_THREAD) */
/* process mutex */
void ink_ProcessMutex_init(ProcessMutex *, const char *name);
void ink_ProcessMutex_destroy(ProcessMutex *);
void ink_ProcessMutex_acquire(ProcessMutex *);
void ink_ProcessMutex_release(ProcessMutex *);
int ink_ProcessMutex_try_acquire(ProcessMutex *);
void ink_ProcessMutex_print(FILE * out, ProcessMutex *);
#endif /* _ink_mutex_h_ */
|
