Runtime Performance of Implicit Conversions (w.r.t. ScalaFX)?

First and slightly off topic, just a heads up,
I've got some code where I am trying to disambiguate statements such as:

logger.trace {
// some code
(msg, arg0, arg1)
}
logger.trace {
// some code
(msg, cause, arg0)
}
logger.trace {
// some code
(marker, msg, arg0, arg1)
}
and
logger.trace {
// some code
(marker, msg, cause, arg0)
}
where cause is a Throwable, msg is a String, marker is a Marker and
the arg's are Any. If I use an implicit conversion approach, there
are some 80 plus implicit methods (22 tuples times low-priority versus
normal priority times 2). The compilations are very, very slow;
minutes rather than seconds.

Back to your topic.
So, for some reason last week I wanted to find out if allocating
a little wrapper object in an implicit conversion method would
be faster or slower than using a pre-allocated object gotten from
a ThreadLocal (and thus avoiding the allocation each call).

Here I ran the body of a loop 10 times. In the body, first
20 thread were created and run where a value was gotten 1,000,000 times from
a ThreadLocal, then initialized and finally data from the object
was accumulated (so, that the whole loop would not be optimized away).
The time for this, after waiting for the threads to complete, was then
printed.
Next, in the body similar code was run (20 threads, 1,000,000 times)
but here the object was allocated with its initialization data.
Again, the time was then printed.

Lastly, the sums of times for both versions was printed.

Per-Loop
THREAD_LOCAL RUN TIME=83143
ALLOCATION RUN TIME=80357
THREAD_LOCAL RUN TIME=78155
ALLOCATION RUN TIME=79674
THREAD_LOCAL RUN TIME=68805
ALLOCATION RUN TIME=81406
THREAD_LOCAL RUN TIME=77705
ALLOCATION RUN TIME=83117
THREAD_LOCAL RUN TIME=77219
ALLOCATION RUN TIME=79223
THREAD_LOCAL RUN TIME=74980
ALLOCATION RUN TIME=83233
THREAD_LOCAL RUN TIME=72354
ALLOCATION RUN TIME=79605
THREAD_LOCAL RUN TIME=77379
ALLOCATION RUN TIME=86342
THREAD_LOCAL RUN TIME=76899
ALLOCATION RUN TIME=87276
THREAD_LOCAL RUN TIME=76595
ALLOCATION RUN TIME=80765
Sums
THREAD_LOCAL TOTAL =763234
ALLOCATION TOTAL =820998

In this run, the ThreadLocal is 7% faster than allocation.

Note that allocating the small implicit conversion object is rather
consistently slower than using a ThreadLocal.
Also, note that all this code is doing is testing whether allocation
is faster/slower than reusing from a ThreadLocal. In normal code,
this effect might be negligible; if the implicit code is called only
1/1000th of the time, then rather than being a, say, 7% effect, it would
be a
0.007% effect.

Disclaimer: This was just a quick and dirty little program. The fact that
the two approaches were, basically, comparable was what was, for me,
interesting. Your results may vary.

Lastly, I think I read recently that in some future version of the
Scala compiler that the implicit method conversion call and object
allocation might be optimized away, if all that is being done is
calling a method of the newly created object with data that was
passed into the method.

Richard

On 01/02/2012 02:10 PM, Ken McDonald wrote:
> Does anyone know of good sources on the ins and outs of implicit
> conversion overhead? I'm interested in using scalafx in a UI library
> that could potentially be used for large amounts of data, and have found
> (a few) conflicting articles on the web on this topic. The scalafx home
> page notes that that they make heavy use of implicit conversions, and
> that while the performance impact of these in real-world situations is
> currently unknown, it could potentially be significant.
>
> Thanks,
> Ken