What is the fastest API to control MIMIC?

Q. What is the fastest API to control MIMIC?

A. SNMP simulations in MIMIC can be controlled from various programming
languages (C++, Tcl, Java, Perl, Python). Each of them has different
performance characteristics (eg. interpreted vs. compiled).

We conducted performance tests to compare these languages.
For the detailed results matrix contact sales@gambitcomm.com .

As expected, the clear winner is C++, in local mode (which is the
most common form of control of MIMIC) by as much as 4 to 1 over the
next contender. The other compiled language, Java, is slower in local
mode, but in remote mode sometimes even faster than C++. The
interpreted languages are significantly slower than C++ in local mode.
In remote mode, the difference between fastest and slowest is at most 20%.

This section attempts to show in detail how they stack up to each
other and help with your selection.

Oftentimes your choice of language will be determined by factors other
than just speed, such as

* knowledge of the language
* efficiency and convenience of other services, eg. graphics, sorting, etc
* policy/politics

but if you have a choice, it could be influenced by speed, specially
if controlling MIMIC means issuing many commands (eg. frequently
configuring thousands of agents, or millions of MIB values) within
time constraints.

The control of MIMIC is a remote procedure call (RPC) mechanism into
the MIMIC server. MIMIC commands are performed via RPC calls. The
performance of an RPC call is impacted by:

time(RPC call) = time(language overhead to package and send request) +
time (transport of request) +
time (MIMIC server dispatch) +
time (transport of response) +
time (language overhead to receive and parse response)


The first thing to realize is that the MIMIC server dispatch time will
be the same for all language bindings. For this test, this can be
considered a constant for each distinct RPC call.

Second, the transport mechanism for the MIMIC RPC calls is TCP for
remote calls (MIMIC client and MIMIC server on distinct machines), and
a faster local transport mechanism for local calls (within a machine),
such as Unix domain sockets for Unix, and pipes for Windows. Some
languages, such as Java, do not support the local transport mechanism,
thus local transport will be slower than on languages that do.

Third, the difference in performance between the language bindings
will be reflected primarily in the time(language overhead to package
request) and time (language overhead to parse response) numbers, thus
our performance tests did focus on calls where the other 3 numbers do
not dominate the equation (such as large requests, for which the
difference will be much smaller).

Fourth, within a language you may find small fluctuations for
different versions of compilers or interpreters. We tested with a
recent version for each language.