Dynamic Invocation

Description

The suite measures the time it takes to complete a dynamic method invocation. The purpose of the suite is to assess the behavior of the dynamic invocation mechanism.

C++ Code

ulonglong ActionPing (void *pArgs)
{
  CORBA::Request_var    vRequest;
  CORBA::ULongLong      iResult;

  vRequest = pPing->_request ("Pong");
  vRequest->set_return_type (CORBA::_tc_ulonglong);
  vRequest->invoke (ORBArgOnly);
  *(vRequest->result ()->value ()) >>= iResult;

  return (iResult);
}

void PingServant::invoke (CORBA::ServerRequest_ptr pRequest)
{
  if (!strcmp (pRequest->operation (), "Pong"))
  {
    // Note that calling arguments is mandated by the
    // standard even when the function has none.

    CORBA::NVList_ptr pArguments;
    CORBA::Any        oResult;

    pORB->create_list (0, pArguments);
    pRequest->arguments (pArguments);
    oResult <<= (CORBA::ULongLong) TIMGetTimestamp ();
    pRequest->set_result (oResult);
  }
  else
  {
    assert (FALSE);
  }
}

Java Code

public final void execute (long [] times)
{
  Request request = pingServer._request ("Pong");

  request.set_return_type (
    BenchBroker.theORB.get_primitive_tc (TCKind.tk_ulonglong));
  request.invoke ();

  times [0] = request.result ().value ().extract_ulonglong ();
}

public final void invoke (ServerRequest request)
{
  if (! request.operation ().equals ("Pong"))
  {
    throw new org.omg.CORBA.BAD_OPERATION ();
  }

  /*
   * Note that calling arguments is mandated by the
   * standard even when the function has none.
   */
  org.omg.CORBA.NVList args = BenchBroker.theORB.create_list (0);
  request.arguments (args);

  org.omg.CORBA.Any result = BenchBroker.theORB.create_any ();
  result.type (
    BenchBroker.theORB.get_primitive_tc (TCKind.tk_ulonglong));
  result.insert_ulonglong (SysInformer.timGetTimestamp ());
  request.set_result (result);
}

Results

The time distribution graphs should display clusters with small variance for both the halfway and the roundtrip times. The clusters should be gradually wider when multiple threads are used.

The time pattern graphs should display a sequence with small variance for both the halfway and the roundtrip times. The sequence should be gradually less uniform when multiple threads are used.

The dependency of both the halfway and the roundtrip times on the number of threads should display constant minimum values and at least linearly increasing median, average and maximum values. The increase over the linear dependency represents the overhead introduced by the concurrent execution.

The client thruput should be constant or decreasing, except on multiprocessor systems, where the thruput should increase initially until the number of threads reaches the number of processors. The decrease under the constant level represents the overhead introduced by the concurrent execution.

The memory usage should be constant or very slightly increasing. The network usage should be constant or very slightly decreasing. The thread usage should grow linearly on the client and reflect the threading model on the server. The processor usage should follow the thruput.

Linux with GCC

TAO Regular

Time Distribution (1 Thread)

The graph depicts the statistical distribution of the time it takes to complete the method invocation. On the X axis are the time intervals, on the Y axis is the percentage of invocations completed within the given time interval.

Time Distribution (10 Threads)

Time Distribution (100 Threads)

Time Pattern (1 Thread)

The graph depicts the pattern of changes of the time it takes to complete the method invocation. On the X axis is the sequential number of the measurement, on the Y axis is the time it took to complete the invocation.

Time Pattern (1 Thread, Zoom)

The graph is a zoom in of the previous graph.

Time Pattern (10 Threads)

Time Pattern (10 Threads, Zoom)

The graph is a zoom in of the previous graph.

Time Pattern (100 Threads)

Time Pattern (100 Threads, Zoom)

The graph is a zoom in of the previous graph.

Dependency On Number Of Threads

The graph depicts the dependency of the time it takes to complete the invocation on the number of threads issuing the invocations concurrently. On the X axis is the number of threads, on the Y axis is the time it took to complete the invocation.