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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
|
#include "tao/RTCORBA/RT_ORBInitializer.h"
#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
ACE_RCSID (RTCORBA,
RT_ORBInitializer,
"$Id$")
#define TAO_RTCORBA_SAFE_INCLUDE
#include "tao/RTCORBA/RTCORBAC.h"
#undef TAO_RTCORBA_SAFE_INCLUDE
#include "tao/RTCORBA/RT_Policy_i.h"
#include "tao/RTCORBA/RT_PolicyFactory.h"
#include "tao/RTCORBA/RT_Protocols_Hooks.h"
#include "tao/RTCORBA/Priority_Mapping_Manager.h"
#include "tao/RTCORBA/Network_Priority_Mapping_Manager.h"
#include "tao/RTCORBA/RT_ORB_Loader.h"
#include "tao/RTCORBA/RT_Stub_Factory.h"
#include "tao/RTCORBA/RT_Endpoint_Selector_Factory.h"
#include "tao/RTCORBA/Continuous_Priority_Mapping.h"
#include "tao/RTCORBA/Linear_Priority_Mapping.h"
#include "tao/RTCORBA/Direct_Priority_Mapping.h"
#include "tao/RTCORBA/Linear_Network_Priority_Mapping.h"
#include "tao/RTCORBA/RT_ORB.h"
#include "tao/RTCORBA/RT_Current.h"
#include "tao/RTCORBA/RT_Thread_Lane_Resources_Manager.h"
#include "tao/Exception.h"
#include "tao/ORB_Core.h"
#include "tao/PI/ORBInitInfo.h"
#include "tao/debug.h"
#include "ace/Service_Repository.h"
#include "ace/Svc_Conf.h"
#include "ace/Sched_Params.h"
static const char rt_poa_factory_name[] = "TAO_RT_Object_Adapter_Factory";
static const ACE_TCHAR rt_poa_factory_directive[] =
ACE_DYNAMIC_SERVICE_DIRECTIVE(
"TAO_RT_Object_Adapter_Factory",
"TAO_RTPortableServer",
"_make_TAO_RT_Object_Adapter_Factory",
"");
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
TAO_RT_ORBInitializer::TAO_RT_ORBInitializer (int priority_mapping_type,
int network_priority_mapping_type,
int ace_sched_policy,
long sched_policy,
long scope_policy,
ACE_Time_Value const &dynamic_thread_idle_timeout)
: priority_mapping_type_ (priority_mapping_type),
network_priority_mapping_type_ (network_priority_mapping_type),
ace_sched_policy_ (ace_sched_policy),
sched_policy_ (sched_policy),
scope_policy_ (scope_policy),
dynamic_thread_idle_timeout_ (dynamic_thread_idle_timeout)
{
}
void
TAO_RT_ORBInitializer::pre_init (PortableInterceptor::ORBInitInfo_ptr info)
{
//
// Register all of the RT related services.
//
// Set the name of the Protocol_Hooks to be RT_Protocols_Hooks.
TAO_ORB_Core::set_protocols_hooks ("RT_Protocols_Hooks");
ACE_Service_Config::process_directive (ace_svc_desc_TAO_RT_Protocols_Hooks);
// Set the name of the stub factory to be RT_Stub_Factory.
TAO_ORB_Core::set_stub_factory ("RT_Stub_Factory");
ACE_Service_Config::process_directive (ace_svc_desc_TAO_RT_Stub_Factory);
// Set the name of the stub factory to be RT_Stub_Factory.
TAO_ORB_Core::set_endpoint_selector_factory ("RT_Endpoint_Selector_Factory");
ACE_Service_Config::process_directive (ace_svc_desc_RT_Endpoint_Selector_Factory);
// Set the name of the thread lane resources manager to be RT_Thread_Lane_Resources_Manager.
TAO_ORB_Core::set_thread_lane_resources_manager_factory ("RT_Thread_Lane_Resources_Manager_Factory");
ACE_Service_Config::process_directive (ace_svc_desc_TAO_RT_Thread_Lane_Resources_Manager_Factory);
// If the application resolves the root POA, make sure we load the RT POA.
TAO_ORB_Core::set_poa_factory (rt_poa_factory_name,
ACE_TEXT_ALWAYS_CHAR (rt_poa_factory_directive));
// Create the initial priority mapping instance.
TAO_Priority_Mapping *pm = 0;
switch (this->priority_mapping_type_)
{
case TAO_PRIORITY_MAPPING_CONTINUOUS:
ACE_NEW (pm,
TAO_Continuous_Priority_Mapping (this->ace_sched_policy_));
break;
case TAO_PRIORITY_MAPPING_LINEAR:
ACE_NEW (pm,
TAO_Linear_Priority_Mapping (this->ace_sched_policy_));
break;
default:
case TAO_PRIORITY_MAPPING_DIRECT:
ACE_NEW (pm,
TAO_Direct_Priority_Mapping (this->ace_sched_policy_));
break;
}
// Set the Priority_Mapping_Manager
TAO_Priority_Mapping_Manager *manager = 0;
ACE_NEW_THROW_EX (manager,
TAO_Priority_Mapping_Manager (pm),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
TAO_Priority_Mapping_Manager_var safe_manager = manager;
info->register_initial_reference ("PriorityMappingManager", manager);
// Create the initial priority mapping instance.
TAO_Network_Priority_Mapping *npm = 0;
switch (this->network_priority_mapping_type_)
{
default:
case TAO_NETWORK_PRIORITY_MAPPING_LINEAR:
ACE_NEW (npm,
TAO_Linear_Network_Priority_Mapping (this->ace_sched_policy_));
break;
}
// Set the Priority_Mapping_Manager
TAO_Network_Priority_Mapping_Manager * network_manager = 0;
// @@ There is a potential memory leak here. If the new() below
// throws an exception, the memory for the network priority
// mapping allocated above will be leaked. Use an auto_ptr<> or
// the appropriate memory management tool.
ACE_NEW_THROW_EX (network_manager,
TAO_Network_Priority_Mapping_Manager (npm),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
TAO_Network_Priority_Mapping_Manager_var safe_network_manager =
network_manager;
info->register_initial_reference ("NetworkPriorityMappingManager",
network_manager);
// Narrow to a TAO_ORBInitInfo object to get access to the
// orb_core() TAO extension.
TAO_ORBInitInfo_var tao_info = TAO_ORBInitInfo::_narrow (info);
if (CORBA::is_nil (tao_info.in ()))
{
if (TAO_debug_level > 0)
ACE_ERROR ((LM_ERROR,
"(%P|%t) TAO_RT_ORBInitializer::pre_init:\n"
"(%P|%t) Unable to narrow "
"\"PortableInterceptor::ORBInitInfo_ptr\" to\n"
"(%P|%t) \"TAO_ORBInitInfo *.\"\n"));
throw ::CORBA::INTERNAL ();
}
// Create the RT_ORB.
CORBA::Object_ptr rt_orb = CORBA::Object::_nil ();
ACE_NEW_THROW_EX (rt_orb,
TAO_RT_ORB (tao_info->orb_core (),
dynamic_thread_idle_timeout_),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
CORBA::Object_var safe_rt_orb = rt_orb;
info->register_initial_reference (TAO_OBJID_RTORB, rt_orb);
// Create the RT_Current.
CORBA::Object_ptr current = CORBA::Object::_nil ();
ACE_NEW_THROW_EX (current,
TAO_RT_Current (tao_info->orb_core ()),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
CORBA::Object_var safe_rt_current = current;
info->register_initial_reference (TAO_OBJID_RTCURRENT, current);
tao_info->orb_core ()->orb_params ()->scope_policy (this->scope_policy_);
tao_info->orb_core ()->orb_params ()->sched_policy (this->sched_policy_);
tao_info->orb_core ()->orb_params ()->ace_sched_policy (this->ace_sched_policy_);
}
void
TAO_RT_ORBInitializer::post_init (PortableInterceptor::ORBInitInfo_ptr info)
{
this->register_policy_factories (info);
}
void
TAO_RT_ORBInitializer::register_policy_factories (
PortableInterceptor::ORBInitInfo_ptr info)
{
// The RTCorba policy factory is stateless and reentrant, so share a
// single instance between all ORBs.
if (CORBA::is_nil (this->policy_factory_.in ()))
{
PortableInterceptor::PolicyFactory_ptr policy_factory;
ACE_NEW_THROW_EX (policy_factory,
TAO_RT_PolicyFactory,
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
this->policy_factory_ = policy_factory;
}
// Bind the same policy factory to all RTCORBA related policy
// types since a single policy factory is used to create each of
// the different types of RTCORBA policies.
static CORBA::PolicyType const type[] = {
RTCORBA::PRIORITY_MODEL_POLICY_TYPE,
RTCORBA::THREADPOOL_POLICY_TYPE,
RTCORBA::SERVER_PROTOCOL_POLICY_TYPE,
RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE,
RTCORBA::PRIVATE_CONNECTION_POLICY_TYPE,
RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE
};
const CORBA::PolicyType *end =
type + sizeof (type) / sizeof (type[0]);
for (CORBA::PolicyType const * i = type;
i != end;
++i)
{
try
{
info->register_policy_factory (*i, this->policy_factory_.in ());
}
catch (const ::CORBA::BAD_INV_ORDER& ex)
{
if (ex.minor () == (CORBA::OMGVMCID | 16))
{
// The factory is already there, it happens because the
// magic initializer in PortableServer.cpp registers
// with the ORB multiple times. This is an indication
// that we should do no more work in this
// ORBInitializer.
return;
}
throw;
}
catch (const ::CORBA::Exception&)
{
// Rethrow any other exceptions...
throw;
}
}
}
TAO_END_VERSIONED_NAMESPACE_DECL
#endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */
|
