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
130
131
132
|
/* -*- C++ -*- */
// $Id$
// SV_Semaphore_Simple.i
#include "ace/SV_Semaphore_Simple.h"
#include "ace/Trace.h"
#undef LUSED
#define LUSED 4 // # of chars used from name
inline int
ACE_SV_Semaphore_Simple::control (int cmd,
semun arg,
int semnum) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::control");
return this->internal_id_ == -1 ?
-1 : ACE_OS::semctl (this->internal_id_, semnum, cmd, arg);
}
// Remove all SV_Semaphores associated with a particular key. This
// call is intended to be called from a server, for example, when it
// is being shut down, as we do an IPC_RMID on the ACE_SV_Semaphore,
// regardless of whether other processes may be using it or not. Most
// other processes should use close() below.
inline int
ACE_SV_Semaphore_Simple::remove (void) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::remove");
int result = this->control (IPC_RMID);
((ACE_SV_Semaphore_Simple *) this)->init ();
return result;
}
// Close a ACE_SV_Semaphore, marking it as invalid for subsequent
// operations...
inline int
ACE_SV_Semaphore_Simple::close (void)
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::close");
return this->init ();
}
// General ACE_SV_Semaphore operation on an array of SV_Semaphores.
inline int
ACE_SV_Semaphore_Simple::op (sembuf op_vec[], int n) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::op");
return this->internal_id_ == -1
? -1 : ACE_OS::semop (this->internal_id_, op_vec, n);
}
inline
ACE_SV_Semaphore_Simple::ACE_SV_Semaphore_Simple (void)
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::ACE_SV_Semaphore_Simple");
this->init ();
}
// Wait until a ACE_SV_Semaphore's value is greater than 0, the
// decrement it by 1 and return. Dijkstra's P operation, Tannenbaums
// DOWN operation.
inline int
ACE_SV_Semaphore_Simple::acquire (int n, int flags) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::acquire");
return this->op (-1, n, flags);
}
inline int
ACE_SV_Semaphore_Simple::acquire_read (int n, int flags) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::acquire_read");
return this->acquire (n, flags);
}
inline int
ACE_SV_Semaphore_Simple::acquire_write (int n, int flags) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::acquire_write");
return this->acquire (n, flags);
}
// Non-blocking version of acquire().
inline int
ACE_SV_Semaphore_Simple::tryacquire (int n, int flags) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::tryacquire");
return this->op (-1, n, flags | IPC_NOWAIT);
}
// Non-blocking version of acquire().
inline int
ACE_SV_Semaphore_Simple::tryacquire_read (int n, int flags) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::tryacquire_read");
return this->tryacquire (n, flags);
}
// Non-blocking version of acquire().
inline int
ACE_SV_Semaphore_Simple::tryacquire_write (int n, int flags) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::tryacquire_write");
return this->tryacquire (n, flags);
}
// Increment ACE_SV_Semaphore by one. Dijkstra's V operation,
// Tannenbaums UP operation.
inline int
ACE_SV_Semaphore_Simple::release (int n, int flags) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::release");
return this->op (1, n, flags);
}
inline int
ACE_SV_Semaphore_Simple::get_id (void) const
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::get_id");
return this->internal_id_;
}
|
