Performance Measurer in Java+Aspect

//There are 2 files below
//Classes whose performance is being measured are in TestClass.java
//AJPerf is the aspect class that measures the performance.

/*
 *
 * Filename       : AJPerf.java
 * Author         : Kashyap Bhatt
 * History        : Created on May 4, 2007
 *
 * export CLASSPATH=$CLASSPATH:/home/om1/aspectj1.5/lib/aspectjlib.jar:/home/om1/aspectj1.5/lib/aspectjrt.jar:/home/om1/aspectj1.5/lib/aspectjtools.jar:/home/om1/aspectj1.5/lib/aspectjweaver.jar
 * export PATH=$PATH:~om1/aspectj1.5/bin/
 * ajc -1.5 -d . *.java
 * aj -classpath E:\AspectJ\lib\aspectjweaver.jar;.;E:\AspectJ\lib\aspectjrt.jar;E:\AspectJ\lib\aspectjtools.jar;E:\AspectJ\lib\aspectjlib.jar AJPerf
 *
 */

//TODO: import classes of your application.
import in.kash.test.* ;
import in.kash.test.TestClass.* ;

import java.util.Stack ;
import java.util.HashMap ;

aspect AJPerf {

//TODO: Change pointcut myClass(), but putting names of your classes.
    pointcut myClass(): within(TestClass) || within(SortInsertion)
                || within(SortExchange) || within(SortSelection) ;

    pointcut myMethod(): myClass() && execution(* *(..)) ;

    pointcut myConstructor(): myClass() && execution(new(..)) ;

    before (): myMethod() || myConstructor() {
        traceEntry( "" + thisJoinPointStaticPart.getSignature() ) ;
    }

    after(): myMethod() || myConstructor() {
        traceExit( "" + thisJoinPointStaticPart.getSignature() ) ;
    }

    public static class MethodPerfInfo {
        public long mTotalTime ;
        public long mNumCalls ;
        MethodPerfInfo() { mTotalTime = 0; mNumCalls = 0; }
        public String toString() { return "mTotalTime = " + mTotalTime + " mNumCalls = " + mNumCalls + "\n" ; }
    }

    private static Stack<Long> mTimeStack = new Stack<Long>() ;
    private static HashMap<String, MethodPerfInfo> mOutMap = new HashMap<String, MethodPerfInfo>(1000) ;

    void traceEntry( String s ) {
        //sop("==>" + s) ;
        mTimeStack.push(new Long(System.nanoTime())) ;
        if( ! mOutMap.containsKey(s) )
            mOutMap.put( s, new MethodPerfInfo() ) ;
    }

    void traceExit( String s ) {
        //sop("<==" + s) ;
        MethodPerfInfo obj = mOutMap.get( s ) ;
        obj.mTotalTime += System.nanoTime() - (mTimeStack.pop()).longValue() ;
        obj.mNumCalls++ ;
        mOutMap.put( s, obj ) ;
    }

    private static void sop( String s ) { System.out.println(s) ; }

    public static void main(String[] args) {
//TODO: call your applications's main here.
        TestClass.main(args) ;

        sop( "\n\nThe OUTPUT:\n" ) ;
        Object[] func_names = mOutMap.keySet().toArray() ;
        sop("Function Name#Total Time(nano)#Number of calls#Time per call(nano)" ) ;
        for( int i = 0; i < func_names.length; i++ ) {
            MethodPerfInfo obj = mOutMap.get(func_names[i]) ;
            sop(func_names[i] + "#" + obj.mTotalTime + "#" + obj.mNumCalls + "#" + Double.toString(obj.mTotalTime/obj.mNumCalls) ) ;
        }
    }
}

//--------------------End of AJPerf.java-------------------

/*
 * Filename       : TestClass.java
 * Author         : Kashyap Bhatt
 * History        : Created on May 4, 2007
 */
package in.kash.test;

import java.math.*;

public class TestClass {

    public static void main ( String[] args ) {
        Integer[] a = new Integer[20];
        Integer[] b ;

        for( int xxx = 0; xxx < 100; xxx++ ) {
            for ( int i = 0; i < 20; i++ ) {
                a[i] = new Integer( (int)(Math.random() * 100) );
            }
            //save a
            b = a ;

            /*System.out.println ( "Before: " );

            for ( int i = 0; i < a.length; i++ ) {
                System.out.print ( i + " " );
            }
            System.out.println ( "" );*/

            SortInsertion.insertion_sort( a, a.length ) ;

            a = b ;
            SortInsertion.shell_sort( a, a.length ) ;

            a = b ;
            SortExchange.bubble_sort( a, a.length ) ;
            a = b ;
            SortExchange.quicksort( a, a.length ) ;

            a = b ;
            SortSelection.selection_sort( a, a.length ) ;
            a = b ;
            SortSelection.heapsort( a, a.length ) ;

            /*System.out.println ( "After: " );
            for ( int i = 0; i < a.length; i++ ) {
                System.out.print ( i + " " );
            }
            System.out.println ( "" );*/
        }
    }

    public TestClass() {
        //System.out.println( "Inside TestClass()" ) ;
    }


    /*
     * Source: http://www.daniweb.com/code/snippet77.html
     * modified to make it NON-generic.
     */

    public static class SortInsertion {
        // Insertion sort
        public static void insertion_sort ( Integer[] list, int size ) {
            for ( int i = 1; i < size; i++ ) {
                Integer save = list[i];
                int j = i;

                while ( j >= 1 && save.compareTo ( list[j - 1] ) < 0 ) {
                    list[j] = list[j - 1];
                    --j;
                }

                list[j] = save;
            }
        }

        // Shell sort
        public static
        void shell_sort ( Integer[] list, int size ) {
            int h = 1;

            while ( h <= size / 9 ) {
                h = 3 * h + 1;
            }

            while ( h > 0 ) {
                for ( int i = h; i < size; i++ ) {
                    Integer save = list[i];
                    int j = i;

                    while ( j >= h && save.compareTo ( list[j - h] ) < 0 ) {
                        list[j] = list[j - h];
                        j -= h;
                    }

                    list[j] = save;
                }

                h /= 3;
            }
        }
    }

    public static class SortExchange {
        // Bubble sort
        public static
        void bubble_sort ( Integer[] list, int size ) {
            int bound = size - 1;

            while ( bound > 0 ) {
                int new_bound = 0;

                for ( int i = 0; i < bound; i++ ) {
                    if ( list[i].compareTo ( list[i + 1] ) > 0 ) {
                        Integer save = list[i];
                        list[i] = list[i + 1];
                        list[i + 1] = save;

                        new_bound = i;
                    }
                }

                bound = new_bound;
            }
        }

        // Quicksort
        private static void quicksort ( Integer[] list, int l, int r ) {
            int[] stack = new int[50];
            int m, top = 0;
            Integer pivot;

            while ( true ) {
                while ( r > l + 10 ) {
                    // Median of three partition
                    m = ( l + r ) / 2;

                    if ( list[l].compareTo ( list[m] ) > 0 ) {
                        Integer save = list[l];
                        list[l] = list[m];
                        list[m] = save;
                    }
                    if ( list[l].compareTo ( list[r] ) > 0 ) {
                        Integer save = list[l];
                        list[l] = list[r];
                        list[r] = save;
                    }
                    if ( list[m].compareTo ( list[r] ) > 0 ) {
                        Integer save = list[m];
                        list[m] = list[r];
                        list[r] = save;
                    }

                    if ( r - l <= 2 ) {
                        break;
                    }

                    pivot = list[m];
                    list[m] = list[r - 1];
                    list[r - 1] = pivot;

                    int i = l;
                    int j = r - 1;

                    while ( true ) {
                        while ( list[++i].compareTo ( pivot ) < 0 ) {
                            // No body
                        }
                        while ( list[--j].compareTo ( pivot ) > 0 ) {
                            // No body
                        }

                        if ( j < i ) {
                            break;
                        }

                        Integer save = list[i];
                        list[i] = list[j];
                        list[j] = save;
                    }

                    pivot = list[i];
                    list[i] = list[r - 1];
                    list[r - 1] = pivot;

                    // Simulated recursive calls
                    if ( j - l > r - i ) {
                        stack[top++] = l;
                        stack[top++] = j;
                        l = i + 1;
                    } else {
                        stack[top++] = i + 1;
                        stack[top++] = r;
                        r = j;
                    }
                }

                if ( top == 0 ) {
                    break;
                }

                r = stack[--top];
                l = stack[--top];
            }
        }

        public static
        void quicksort ( Integer[] list, int size ) {
            quicksort ( list, 0, size - 1 );
            SortInsertion.insertion_sort ( list, size );
        }
    }

    public static class SortSelection {
        // Selection sort
        public static
        void selection_sort ( Integer[] list, int size ) {
            for ( int i = 0; i < size - 1; i++ ) {
                int min = i;

                for ( int j = i + 1; j < size; j++ ) {
                    if ( list[j].compareTo ( list[min] ) < 0 ) {
                        min = j;
                    }
                }

                if ( min != i ) {
                    Integer save = list[i];
                    list[i] = list[min];
                    list[min] = save;
                }
            }
        }

        // Heapsort
        private static void push_down ( Integer[] list, int l, int r ) {
            int i, j;

            for ( i = l; ( j = i * 2 + 1 ) <= r; i = j ) {
                if ( j + 1 <= r && list[j + 1].compareTo ( list[j] ) > 0 ) {
                    ++j;
                }

                Integer save = list[i];
                list[i] = list[j];
                list[j] = save;
            }

            while ( true ) {
                j = ( i - 1 ) / 2;

                if ( j < l || j == i || list[j].compareTo ( list[i] ) > 0 ) {
                    break;
                }

                Integer save = list[i];
                list[i] = list[j];
                list[j] = save;

                i = j;
            }
        }

        public static
        void heapsort ( Integer[] list, int size ) {
            if ( size-- < 2 ) {
                return;
            }

            int i;

            for ( i = ( size - 1 ) / 2; i >= 0; i-- ) {
                push_down ( list, i, size );
            }

            while ( size > 0 ) {
                Integer save = list[size];
                list[size] = list[0];
                list[0] = save;

                push_down ( list, 0, --size );
            }
        }
    }

}