int main(int argc, char* argv[])
{
Logger *logger = new Logger;
int n_loops = 10;
ACE_Future<u_long> logresult;
ACE_Future<const char*> name;
logger->open(0);
for (size_t i = 0; i < n_loops; i++)
{
char* msg = new char[50];
ACE_DEBUG((LM_DEBUG, "Issuing a non-blocking logging call\n"));
ACE_OS::sprintf(msg, "This is iteration %d", i);
logresult = logger->logMsg(msg);
}
ACE_DEBUG((LM_DEBUG, "(%t) Invoked all the log calls and can now continue with other work \n"));
name = logger->name();
if(name.ready())
ACE_DEBUG((LM_DEBUG, "Name is ready! \n"));
else
ACE_DEBUG((LM_DEBUG, "Blocking till I get the result of that call \n"));
const char* task_name;
name.get(task_name);
ACE_DEBUG((LM_DEBUG, "(%t)==> The name of the task is: %s\n\n\n", task_name));
ACE_Thread_Manager::instance()->wait();
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Future_Test"));
#if defined (ACE_HAS_THREADS)
// @@ Should make these be <auto_ptr>s...
Prime_Scheduler *andres, *peter, *helmut, *matias;
// Create active objects..
ACE_NEW_RETURN (andres,
Prime_Scheduler (ACE_TEXT ("andres")),
-1);
int result = andres->open ();
ACE_TEST_ASSERT (result != -1);
ACE_NEW_RETURN (peter,
Prime_Scheduler (ACE_TEXT ("peter")),
-1);
result = peter->open ();
ACE_TEST_ASSERT (result != -1);
ACE_NEW_RETURN (helmut,
Prime_Scheduler (ACE_TEXT ("helmut")),
-1);
result = helmut->open ();
ACE_TEST_ASSERT (result != -1);
// Matias passes all asynchronous method calls on to Andres...
ACE_NEW_RETURN (matias,
Prime_Scheduler (ACE_TEXT ("matias"),
andres),
-1);
result = matias->open ();
ACE_TEST_ASSERT (result != -1);
for (int i = 0; i < n_loops; i++)
{
{
ACE_Future<u_long> fresulta;
ACE_Future<u_long> fresultb;
ACE_Future<u_long> fresultc;
ACE_Future<u_long> fresultd;
ACE_Future<u_long> fresulte;
ACE_Future<const ACE_TCHAR *> fname;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) going to do a non-blocking call\n")));
// Spawn off the methods, which run in a separate thread as
// active object invocations.
fresulta = andres->work (9013);
fresultb = peter->work (9013);
fresultc = helmut->work (9013);
fresultd = matias->work (9013);
fname = andres->name ();
// See if the result is available...
if (fresulta.ready ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) wow.. work is ready.....\n")));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) non-blocking call done... now blocking...\n")));
// Save the result of fresulta.
fresulte = fresulta;
if (i % 3 == 0)
{
// Every 3rd time... disconnect the futures... but
// "fresulte" should still contain the result...
fresulta.cancel (10ul);
fresultb.cancel (20ul);
fresultc.cancel (30ul);
fresultd.cancel (40ul);
}
u_long resulta = 0, resultb = 0, resultc = 0, resultd = 0, resulte = 0;
fresulta.get (resulta);
fresultb.get (resultb);
fresultc.get (resultc);
fresultd.get (resultd);
fresulte.get (resulte);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) result a %u\n")
ACE_TEXT ("(%t) result b %u\n")
ACE_TEXT ("(%t) result c %u\n")
ACE_TEXT ("(%t) result d %u\n")
ACE_TEXT ("(%t) result e %u\n"),
(u_int) resulta,
(u_int) resultb,
(u_int) resultc,
(u_int) resultd,
(u_int) resulte));
const ACE_TCHAR *name = 0;
fname.get (name);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) name %s\n"),
name));
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) task_count %d future_count %d ")
ACE_TEXT ("capsule_count %d method_request_count %d\n"),
task_count.value (),
future_count.value (),
capsule_count.value (),
method_request_count.value ()));
}
// Close things down.
andres->end ();
peter->end ();
helmut->end ();
matias->end ();
ACE_Thread_Manager::instance ()->wait ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) task_count %d future_count %d ")
ACE_TEXT ("capsule_count %d method_request_count %d\n"),
task_count.value (),
future_count.value (),
capsule_count.value (),
method_request_count.value ()));
{
// Check if set then get works, older versions of <ACE_Future>
// will lock forever (or until the timer expires), will use a
// small timer value to avoid blocking the process.
ACE_Future<int> f1;
f1.set (100);
// Note you need to use absolute time, not relative time.
ACE_Time_Value timeout (ACE_OS::gettimeofday () + ACE_Time_Value (10));
int value = 0;
if (f1.get (value, &timeout) == 0
&& value == 100)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Ace_Future<T>::Set followed by Ace_Future<T>::Get works.\n")));
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("ACE_Future<T>::Set followed by Ace_Future<T>::Get does ")
ACE_TEXT ("not work, broken Ace_Future<> implementation.\n")));
}
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Checking if Ace_Future<T>::operator= is implemented ")
ACE_TEXT ("incorrectly this might crash the program.\n")));
ACE_Future<int> f1;
{
// To ensure that a rep object is created.
ACE_Future<int> f2 (f1);
}
// Now it is one ACE_Future<int> referencing the rep instance
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("0.\n")));
//Check that self assignment works.
f1 = f1;
// Is there any repesentation left, and if so what is the ref
// count older ACE_Future<> implementations have deleted the rep
// instance at this moment
// The stuff below might crash the process if the <operator=>
// implementation was bad.
int value = 0;
ACE_Time_Value timeout (ACE_OS::gettimeofday () + ACE_Time_Value (10));
f1.set (100);
f1.get (value, &timeout);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("1.\n")));
{
// Might delete the same data a couple of times.
ACE_Future<int> f2 (f1);
f1.set (100);
f1.get (value, &timeout);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("2.\n")));
{
ACE_Future<int> f2 (f1);
f1.set (100);
f1.get (value, &timeout);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("3.\n")));
{
ACE_Future<int> f2 (f1);
f1.set (100);
f1.get (value, &timeout);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("4.\n")));
{
ACE_Future<int> f2 (f1);
f1.set (100);
f1.get (value, &timeout);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("5.\n")));
{
ACE_Future<int> f2 (90);
f2.get (value, &timeout);
f1.get (value, &timeout);
}
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("No it did not crash the program.\n")));
delete andres;
delete peter;
delete helmut;
delete matias;
#else
ACE_ERROR ((LM_INFO,
ACE_TEXT ("threads not supported on this platform\n")));
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return 0;
}