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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// Token_Manager
//
// = AUTHOR
// Tim Harrison (harrison@cs.wustl.edu)
//
// ============================================================================
#if !defined (ACE_TOKEN_MANAGER_H)
#define ACE_TOKEN_MANAGER_H
#include "ace/Synch.h"
#include "ace/Map_Manager.h"
#include "ace/Local_Tokens.h"
class ACE_Local_Mutex;
class ACE_Mutex_Token;
class ACE_Export ACE_Token_Manager : public ACE_Cleanup
// = TITLE
// Manages all tokens in a process space.
//
// = DESCRIPTION
// Factory: Proxies use the token manager to obtain token
// references. This allows multiple proxies to reference the same
// logical token.
// Deadlock detection: Tokens use the manager to check for
// deadlock situations during acquires.
// = EXTENDING TOKENS
// To add a new type of token (e.g. semaphore), do the following
// steps: 1. Create a new derivation of ACE_Token. This class
// defines the semantics of the new Token. 2. Create a
// derivation of ACE_Token_Manager. You will only need to
// redefine make_mutex.
{
public:
ACE_Token_Manager (void);
virtual ~ACE_Token_Manager (void);
// Set/get a pointer to token manager singleton.
static ACE_Token_Manager *instance (void);
void instance (ACE_Token_Manager *);
void get_token (ACE_Token_Proxy *, const char *token_name);
// The Token manager uses ACE_Token_Proxy::token_id_ to look for
// an existing token. If none is found, the Token Manager calls
// ACE_Token_Proxy::create_token to create a new one. When
// finished, sets ACE_Token_Proxy::token_. <token_name> uniquely
// id's the token name.
int check_deadlock (ACE_Token_Proxy *proxy);
int check_deadlock (ACE_Tokens *token, ACE_Token_Proxy *proxy);
// returns 1 if the acquire will _not_ cause deadlock.
// returns 0 if the acquire _will_ cause deadlock.
// this method ignores recursive acquisition. That is, it will not
// report deadlock if the client holding the token requests the
// token again. Thus, it assumes recursive mutexes.
void release_token (ACE_Tokens *&token);
// notify the token manager that a token has been released. If as a
// result, there is no owner of the token, the token is deleted.
ACE_TOKEN_CONST::MUTEX &mutex (void);
// This is to allow Tokens to perform atomic transactions. The
// typical usage is to acquire this mutex, check for a safe_acquire,
// perform some queueing (if need be) and then release the lock.
// This is necessary since safe_acquire is implemented in terms of
// the Token queues.
void dump (void) const;
// Dump the state of the class.
void debug (int d);
// Turn debug mode on/off.
private:
int debug_;
// Wether to print debug messages or not.
static ACE_Token_Manager *token_manager_;
// pointer to singleton token manager.
static ACE_TOKEN_CONST::MUTEX creation_lock_;
// make sure that token_manager_ is created atomically (only once!)
ACE_Tokens *token_waiting_for (const char *client_id);
// return the token that the given client_id is waiting for, if any
ACE_TOKEN_CONST::MUTEX lock_;
// ACE_Mutex_Token used to lock internal data structures.
typedef ACE_Token_Name TOKEN_NAME;
// This may be changed to a template type.
typedef ACE_Map_Manager<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex>
COLLECTION;
// COLLECTION maintains a mapping from token names to ACE_Tokens*
typedef ACE_Map_Iterator<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex>
COLLECTION_ITERATOR;
// Allows iterations through collection_
typedef ACE_Map_Entry<TOKEN_NAME, ACE_Tokens *>
COLLECTION_ENTRY;
// Allows iterations through collection_
COLLECTION collection_;
// COLLECTION maintains a mapping from token names to ACE_Tokens*.
};
#if defined (__ACE_INLINE__)
#include "ace/Token_Manager.i"
#endif /* __ACE_INLINE__ */
#endif /* ACE_TOKEN_MANAGER_H */
|
