blob: 9aae513b53070ba7320f19e36a92f8a4507989f5 (
plain)
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
|
//
// $Id$
//
// = DESCRIPTION
// Keep constants required by both Event Service implementation and
// the Scheduling Service implementation.
//
#if !defined (ACE_ES_CONSTANTS_H)
#define ACE_ES_CONSTANTS_H
#include <ace/Message_Block.h>
#include <ace/Synch.h>
const int ACE_ES_MAX_SUBSCRIPTIONS = 32;
// This is the number of events a consumer can subscribe to.
//const int ACE_ES_MAX_SUPPLIERS = 100;
// Max number of suppliers that a channel can handle.
const int ACE_ES_MAX_CONSUMERS_PER_SUPPLIER = 100;
// Max number of consumers that one supplier can have subscribed to
// one type of event (including source-only). This restriction is
// very lightweight since subscription lists are dynamic. This
// constant is only used for ACE_ES_Simple_Set in Event_Channel.* for
// disconnecting consumers. Since these objects are allocated off the
// stack, we can increase this number without requiring more heap
// memory.
// = Predefined event types. All application defined types should be
// relative to ACE_ES_EVENT_UNDEFINED.
const u_long ACE_ES_EVENT_ANY = 0;
const u_long ACE_ES_EVENT_SHUTDOWN = 1;
const u_long ACE_ES_EVENT_ACT = 2;
const u_long ACE_ES_EVENT_NOTIFICATION = 3;
const u_long ACE_ES_EVENT_TIMEOUT = 4;
const u_long ACE_ES_EVENT_INTERVAL_TIMEOUT = 5;
const u_long ACE_ES_EVENT_DEADLINE_TIMEOUT = 6;
const u_long ACE_ES_GLOBAL_DESIGNATOR = 7;
const u_long ACE_ES_CONJUNCTION_DESIGNATOR = 8;
const u_long ACE_ES_DISJUNCTION_DESIGNATOR = 9;
const u_long ACE_ES_EVENT_UNDEFINED = 16;
// The max number of priorities provided by the target platform.
// TODO: This should be defined in ACE (somehow) and only mapped here
// to some variables (and even that is doubtful).
const long ACE_Scheduler_MAX_PRIORITIES = 5;
const u_long ACE_Scheduler_Rates[ACE_Scheduler_MAX_PRIORITIES] = {
250000, 500000, 1000000, 2000000, 10000000 };
// The minimum preemption priority.
const long ACE_Scheduler_MIN_PREEMPTION_PRIORITY =
ACE_Scheduler_MAX_PRIORITIES - 1;
// Max preemption priority.
const long ACE_Scheduler_MAX_PREEMPTION_PRIORITY = 0;
// This is the maximum sub priority.
const u_long ACE_Scheduler_MAX_SUB_PRIORITY =
ACE_Message_Block::MB_USER - 1;
// This is the minimum sub priority.
const u_long ACE_Scheduler_MIN_SUB_PRIORITY =
ACE_Message_Block::MB_NORMAL;
typedef ACE_Thread_Mutex ACE_ES_MUTEX;
typedef ACE_Guard<ACE_ES_MUTEX> ACE_ES_GUARD;
typedef ACE_RW_Thread_Mutex ACE_ES_RW_LOCK;
typedef ACE_Write_Guard<ACE_ES_RW_LOCK> ACE_ES_WGUARD;
typedef ACE_Read_Guard<ACE_ES_RW_LOCK> ACE_ES_RGUARD;
// ************************************************************
// Channel configuration parameters.
// ACE_ES_DISPATCHING_MODULE determines what Dispatching Module is
// used by the channel. ACE_ES_Dispatching_Base is a null dispatcher
// that can be used to build an EFD.
#define ACE_ES_DISPATCHING_MODULE ACE_ES_Priority_Dispatching
//#define ACE_ES_DISPATCHING_MODULE ACE_ES_Dispatching_Base
// This is the number of threads spawned for *each* priority queue in
// the channel's Dispatching Module. This is used by the channel when
// creating the dispatch module.
const int THREADS_PER_DISPATCH_QUEUE = 1;
// This is the chunk size of the cached allocator for
// ACE_ES_Event_Container.
const int ACE_ES_EVENT_CONTAINER_MEMORY_POOL = 1024;
const int ACE_ES_EVENT_MEMORY_POOL = 1024;
const int ACE_ES_DISPATCH_REQUEST_MEMORY_POOL = 1024;
#endif /* ACE_ES_CONSTANTS_H */
|