playing with dacapo using aspectj [the series about program instrumentation is done]

I verified two hypothesis on dacapo.

The first is, there are many invocations to thread-safe library, such as synchronizedMap (Collections.synchronized()).

However, I find this hypothesis is wrong. 

I wrote the following aspect, aimed at pinpointing such invocations.

However, none are identified for avrora, batik....

    public pointcut executionOfMap(Object obj) :

          call(*  java.util.Map+.put(..)) && target(obj) ;

    // if you change it to execution, it does not work as aj cannot weave jdk classes.

    // use target(), instead of this(). this() is for the view inside of the invocation, like execution().

    before(Object obj): executionOfMap(obj)

    {

       Class clazz =obj.getClass();

       if(clazz.getName().contains("Synchronized"))

       {

           System.out.println(clazz);

       }

//       Method[] ms =clazz.getMethods();

//       for(Method m:ms)

//       {        

//           if((m.getModifiers()& Modifier.PUBLIC)!=0)

//           {

//               System.out.println(m);

//           }

//       }

    }

The second hypothesis is, there are lots of locking operations.

I wrote an aspect to capture the locking operations. 

For the convenience of future use, let me reitereate the deployment process.

1) ajc Locking.aj -outxml -outjar xx.jar

1.5) Update the Meta info in xx.jar

"Do not forget to include the option for support weaving synchronizations.

add <weaver options="-Xjoinpoints:synchronization"/> to the METAINFO/aop-ajc.xml"

2) java -javaagent:aspectweaver.jar -cp aspectrt.jar:dacapo.jar:xx.jar Harness avrora.

import java.util.HashMap;

import java.util.Iterator;

public aspect Locking {

    public static HashMap map = new HashMap();

    pointcut scope(): !within(Locking) && !cflow(within(Locking));

    after(Object l): lock() && args(l) && scope() {

//    System.out.println("lock:" + l.hashCode());

        Integer value = (Integer)map.get(l);

        if(value==null)

        {

            map.put(l, new Integer(1));

        }else {

            map.put(l, new Integer(value.intValue()+1));

        }

    }

    before():call(* System.exit(..))

    {

        Iterator keyit =map.keySet().iterator();

        while (keyit.hasNext()) {

            Object object = (Object) keyit.next();

            System.out.println(""+object.getClass() + object.hashCode());

            System.out.println(map.get(object));

        }

    }

//after(Object l): unlock() && args(l) && scope() {

//    System.out.println("unlock:" + l.hashCode());

//}

}

It will report the number of locking operations on each lock.

I found that few lock operations are carried out except for the case of eclipse and h2.

Also, I found an interesting scenario that, the code often use synchronized(hashmap) {} instead of invoking the synchronizedMap methods.

More trace files are in the folder ./asm/tami/tamiflexcpu2