[aspectc-user] aspect efficiency
daniel.lohmann at informatik.uni-erlangen.de
Mon Aug 8 12:00:03 CEST 2005
We are currently working on a micro-benchmark suite that should anwser
exactly this questions. The results will be made available on
acpectc.org quite soon. Some general results are, however:
1) Simple before() and after() advice is actually inlined by the
compiler and leads to no overhead regarding CPU cycles or stack usage.
2) around() is not very efficient in the current implementation, as it
uses internally the action object for the implementation of
tjp->proceed(), which results in a function-pointer call that can not be
inlined. The action object furthermore occupies some stack space.
Olaf is currently implementing a more efficient code generation pattern
for around() that does not depend on the action object. With this new
implementation, around() will hopefully be as efficient as
3) The overhead of any code advice type is mainly determined by the
amount of joinpoint context accessed by the advice code (e.g.
tjp->that()). Information such as the pointers returned by that(),
target(), arg() are stored in the joinpoint object. They require some
stack space and some cycles for intialisation. The actual call to
functions such as tjp->that(), however, are inlined, therefore it should
not matter if you call tem once or several times.
Moreover, ac++ optimizes the generated code by providing only those
information in the joinpoint object that is actually requested by the
advice body. If, for instance, tjp->that() is not called, it does not
lead to stack space and initialization overhead.
4) All of the above highly depend on the inlining capabilities of the
backend compiler. In our g++ measurements we got dramatic differences
between using O0, O3 and Os optimizations. Especially using O0, which
makes the compiler to do not inline anything, results in higher runtime
and stack costs due to many additional function calls.
You might also take a look into the generated code. It looks a bit,
well, not so nice in the beginning, but you quickly get used to it.
Hope that helps
Jamal Siadat wrote:
>I was just wndering how efficient is the code produced by aspectc++. I
>mean are the advices all inlined? would the extra level of indirection
>used by tjp->that()->... effect the performance of a given software ( I
>mean even if its in milliseconds) ? How much inderection/overhead is
>actually produced for every advice? or tjp->that? if any ( in terms of
>other function calls so if we add 4 or 5 other methods for every piece of
>advice and if we dont inline them then it might degragade the performance
>I'm just wondering if I should expect any performace degregation if use
>ac++ in a given system.
>P.S: if there are extra levels of indirection is there any work being done
>to reduce them? or is this the nature of AOP and one should expect it?
>aspectc-user mailing list
>aspectc-user at aspectc.org
More information about the aspectc-user