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
|
//
// $Id$
//
#include "Client_Task.h"
#include "tao/TimeBaseC.h"
#include "tao/MessagingC.h"
ACE_RCSID(MT_Timeout, Client_Task, "$Id$")
Client_Task::Client_Task (CORBA::ORB_ptr orb,
Test::Sleep_Service_ptr sleep_service,
int iterations,
CORBA::ULong sleep_time,
CORBA::ULong timeout)
: orb_ (CORBA::ORB::_duplicate (orb))
, sleep_service_ (Test::Sleep_Service::_duplicate (sleep_service))
, iterations_ (iterations)
, sleep_time_ (sleep_time)
, timeout_ (timeout)
, successful_calls_ (0)
, timed_out_calls_ (0)
{
}
int
Client_Task::successful_calls (void) const
{
return this->successful_calls_;
}
int
Client_Task::timed_out_calls (void) const
{
return this->timed_out_calls_;
}
int
Client_Task::svc (void)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting client task\n"));
ACE_DECLARE_NEW_CORBA_ENV;
int successful_calls = 0;
int timed_out_calls = 0;
ACE_TRY
{
this->validate_connection (ACE_TRY_ENV);
ACE_TRY_CHECK;
CORBA::Object_var object =
this->orb_->resolve_initial_references ("PolicyCurrent",
ACE_TRY_ENV);
ACE_TRY_CHECK;
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV);
ACE_TRY_CHECK;
TimeBase::TimeT timeout_period = 10 * this->timeout_;
CORBA::Any timeout_as_any;
timeout_as_any <<= timeout_period;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
this->orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
timeout_as_any,
ACE_TRY_ENV);
ACE_TRY_CHECK;
policy_current->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE,
ACE_TRY_ENV);
ACE_TRY_CHECK;
for (int i = 0; i != this->iterations_; ++i)
{
int retval = this->one_iteration (ACE_TRY_ENV);
ACE_TRY_CHECK;
if (retval == 1)
successful_calls++;
else if (retval == 0)
timed_out_calls++;
#if 0
if (i % 50 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Client_Task::svc %d / %d iterations\n",
i, this->iterations_));
}
#endif /* 0 */
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"Exception caught:");
return -1;
}
ACE_ENDTRY;
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client task finished\n"));
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
this->successful_calls_ += successful_calls;
this->timed_out_calls_ += timed_out_calls;
return 0;
}
void
Client_Task::validate_connection (CORBA::Environment &ACE_TRY_ENV)
{
ACE_TRY
{
for (int i = 0; i != 100; ++i)
{
(void) this->sleep_service_->go_to_sleep (0, ACE_TRY_ENV);
ACE_TRY_CHECK;
}
}
ACE_CATCH (CORBA::TRANSIENT, ex)
{
// Ignore transient exceptions
}
ACE_ENDTRY;
ACE_CHECK;
}
int
Client_Task::one_iteration (CORBA::Environment &ACE_TRY_ENV)
{
ACE_TRY
{
ACE_Time_Value start = ACE_OS::gettimeofday ();
this->sleep_service_->go_to_sleep (this->sleep_time_,
ACE_TRY_ENV);
ACE_TRY_CHECK;
ACE_Time_Value end = ACE_OS::gettimeofday ();
if (this->sleep_time_ > this->timeout_)
{
// If we don't sleep then the next request will also
// timeout:
// The server is already sleeping, the client sends a new
// request, but the server cannot process it until the
// previous sleep completes. The sleep times for multiple
// requests accumulate, and the client always fails.
CORBA::ULong remainder =
this->sleep_time_ - this->timeout_;
ACE_Time_Value tv (0, remainder);
ACE_OS::sleep (tv);
}
if (this->timeout_ > 0)
{
CORBA::ULong max_milliseconds = this->timeout_ / 1000;
ACE_Time_Value elapsed = end - start;
CORBA::ULong elapsed_milliseconds = elapsed.msec ();
if (elapsed_milliseconds > max_milliseconds)
{
CORBA::ULong difference =
elapsed_milliseconds - max_milliseconds;
// If the different is more than 10 milliseconds we are
// *way* off, this is an error.
if (difference > 10)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Elapsed time = %d, expected %d\n",
elapsed_milliseconds, max_milliseconds));
return -1;
}
}
}
return 1;
}
ACE_CATCH(CORBA::TIMEOUT, to_exp)
{
// Ignore this exception, it is usually caused by a transient
// condition
return 0;
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"Exception caught:");
}
ACE_ENDTRY;
return -1;
}
|
