Re: [aspectj-users] lazyTJP optimization for around advice

[Hmil P <amil@xxxxxx>]

I'm having fun playing with decompilers to see what is really going on and
figuring out what is optimal 

Unfortunately, I cannot use the traditional AspectJ syntax for this project.
However, I am able to do the proceeding inside my around advice rather than
in Profiler.profile().

Originally, I was using before+after advice as well as a stack of function
calls to achieve the profiling, which would allow me to skip join point
instantiation in ALL situations, *as I am only interested in
thisJoinPointStaticPart.getSignature() and the arguments to the method
execution*. Anyways, I decided the instantiation cost associated with around
advice was less than the cost of using a stack.

	@Pointcut("(execution(* Print.ech*(int))) && args(i) && if()")
	public static boolean pc(int i, JoinPoint.StaticPart
thisJoinPointStaticPart) {
		return Profiler.enabled() &&
Profiler.enabled(thisJoinPointStaticPart.getSignature().getDeclaringTypeName());
	}

	@Before("pc(i, tjsp)")
	public void beforeCall(int i, JoinPoint.StaticPart tjsp) {
		Profiler.begin(tjsp, new Object [] { i });
	}

	@After("pc(i, tjsp)")
	public void afterCall(int i, JoinPoint.StaticPart tjsp) {
		Profiler.end(tjsp, new Object [] { i });
	}
-------------Decompiled woven code-------------
	public int echo(int num) {
		int i = num;
		int j;
		try {
			if (ScrapAspect.pc(i, ajc$tjp_0))
				ScrapAspect.aspectOf().beforeCall(i, ajc$tjp_0);
			j = num;
		} catch (Throwable localThrowable) {
			if (ScrapAspect.pc(i, ajc$tjp_0))
				ScrapAspect.aspectOf().afterCall(i, ajc$tjp_0);
			throw localThrowable;
		}
		if (ScrapAspect.pc(i, ajc$tjp_0))
			ScrapAspect.aspectOf().afterCall(i, ajc$tjp_0);
		return j;
	}


Given this information, is there any way to achieve the profiling without
and stack and without instantiating a JoinPoint?

---
Also, it looks like lazyTJP is implemented for before advice when it uses
thisJoinPoint (using a decompiler):
	public int echo(int num) {
		int i = num;
		if (ScrapAspect.pc(i))
			ScrapAspect.aspectOf().beforeCall(
					i,
					org.aspectj.runtime.reflect.Factory.makeJP(ajc$tjp_0, this,
							this, org.aspectj.runtime.internal.Conversions
									.intObject(i)));
		return num;
	}


But not for a combination of both before and after advice:
	public int echo(int num) {
		int i = num;
		org.aspectj.lang.JoinPoint localJoinPoint =
org.aspectj.runtime.reflect.Factory
				.makeJP(ajc$tjp_0, this, this,
						org.aspectj.runtime.internal.Conversions.intObject(i));
		if (ScrapAspect.pc(i))
			ScrapAspect.aspectOf().beforeCall(i, localJoinPoint);
		if (ScrapAspect.pc(i))
			return org.aspectj.runtime.internal.Conversions
					.intValue(echo_aroundBody1$advice(
							this,
							i,
							localJoinPoint,
							ScrapAspect.aspectOf(),
							(org.aspectj.lang.ProceedingJoinPoint) localJoinPoint,
							i));
		return echo_aroundBody0(this, i, localJoinPoint);
	}


Anyhow, it looks like 311749 is not too far off. Do you have any idea of if
and when it would be implemented?



--
View this message in context: http://aspectj.2085585.n4.nabble.com/lazyTJP-optimization-for-around-advice-tp4650646p4650651.html
Sent from the AspectJ - users mailing list archive at Nabble.com.