test/jdk/java/lang/instrument/TransformerManagementThreadAddTests.java

/*
 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/**
 * @test
 * @bug 4882798
 * @summary multi-thread test to exercise sync and contention for adds to transformer registry
 * @author Gabriel Adauto, Wily Technology
 *
 * @run build TransformerManagementThreadAddTests
 * @run shell MakeJAR.sh redefineAgent
 * @run main/othervm -javaagent:redefineAgent.jar TransformerManagementThreadAddTests TransformerManagementThreadAddTests
 */
import java.io.*;
import java.lang.instrument.*;
import java.security.ProtectionDomain;
import java.util.*;

public class TransformerManagementThreadAddTests extends ATestCaseScaffold
{
    public static void
    main (String[] args)
        throws Throwable {
        ATestCaseScaffold   test = new TransformerManagementThreadAddTests(args[0]);
        test.runTest();
    }

    protected void
    doRunTest()
        throws Throwable {
        testMultiThreadAdds();
    }


    /**
     * CONFIGURATION FOR TEST
     * ----------------------
     * Set these variables to different values to test the object that
     * manages the transformers.
     *
     * MIN_TRANS: the minimum number of transformers to add by a thread
     * MAX_TRANS: the maximum number of transformers to add by a thread
     *      There will be a total of MAX_TRANS-MIN_TRANS+1 threads created.
     *      Each thread will add between MIN_TRANS and MAX_TRANS transformers
     *      to the manager.
     *
     * REMOVE_THREADS: the number of threads to run that spend their time
     *                  removing transformers
     */
    protected static final int MIN_TRANS = 33;
    protected static final int MAX_TRANS = 45;
    protected static final int REMOVE_THREADS = 5;

    protected static final boolean LOG_TRANSFORMATIONS = false;

    /**
     * Field variables
     */
    protected static final int TOTAL_THREADS = MAX_TRANS - MIN_TRANS + 1;

    private byte[]          fDummyClassBytes;
    // fCheckedTransformers is a Vector that is used to verify
    // that the transform() function is called in the same
    // order in which the transformers were added to the
    // TransformerManager. The test currently verifies that all
    // transformers for a specific worker thread are in
    // increasing order by index value.
    private Vector              fCheckedTransformers;
    private Instrumentation fInstrumentation;
    private int             fFinished;
    private ExecuteTransformersThread fExec;

    // Need to use this for synchronization in subclass
    protected Vector            fAddedTransformers;
    private String          fDummyClassName;

    /**
     * Constructor for TransformerManagementThreadAddTests.
     * @param name  Name for the test
     */
    public TransformerManagementThreadAddTests(String name)
    {
        super(name);

        fCheckedTransformers = new Vector();
        fAddedTransformers = new Vector();

        fDummyClassName = "DummyClass";
        String resourceName = "DummyClass.class";
        File f = new File(System.getProperty("test.classes", "."), resourceName);
        System.out.println("Reading test class from " + f);
        try
        {
            InputStream redefineStream = new FileInputStream(f);
            fDummyClassBytes = NamedBuffer.loadBufferFromStream(redefineStream);
        }
        catch (IOException e)
        {
            fail("Could not load the class: "+resourceName);
        }
    }

    public void
    testMultiThreadAdds()
    {
        TransformerThread[] threads = new TransformerThread[TOTAL_THREADS];
        for (int i = MIN_TRANS; i <= MAX_TRANS; i++)
        {
            int index = i - MIN_TRANS;
            threads[index] = new TransformerThread("Trans"+prettyNum(index,2), i);
        }

        ExecuteTransformersThread exec = new ExecuteTransformersThread();
        exec.start();
        for (int i = threads.length - 1; i >= 0; i--)
        {
            threads[i].start();
        }

        // Effective Java - Item 48: Synchronize access to shared mutable data
        // Don't use a direct field getter.
        while (!exec.isDone())
        {
            // Effective Java - Item 51: Don't depend on the thread scheduler
            // Use sleep() instead of yield().
            try {
                Thread.sleep(500);
            } catch (InterruptedException ie) {
            }
        }
        assertTrue(finalCheck());

        if (LOG_TRANSFORMATIONS) {
            printTransformers();
        }
    }

    /**
     * Returns the Instrumentation.
     * @return Instrumentation  the data type with JPLIS calls
     */
    public Instrumentation getInstrumentation()
    {
        return fInstrumentation;
    }

    /**
     * Returns the execution thread
     * @return ExecuteTransformersThread
     */
    protected ExecuteTransformersThread getExecThread()
    {
        return fExec;
    }

    /**
     * Sets the execution thread
     * @param exec The execution thread to set
     */
    protected void setExecThread(ExecuteTransformersThread exec)
    {
        this.fExec = exec;
    }

    // Effective Java - Item 48: Synchronize access to shared mutable data
    // Document a synchronized setter.
    protected synchronized void
    threadFinished(Thread t)
    {
        fFinished++;
    }

    // Effective Java - Item 48: Synchronize access to shared mutable data
    // Provide synchronized getter.
    protected synchronized boolean
    threadsDone()
    {
        return fFinished == TOTAL_THREADS;
    }

    /**
     * Method testCompleted.
     * @return boolean
     */
    protected boolean
    testCompleted()
    {
        // Effective Java - Item 48: Synchronize access to shared mutable data
        // Don't use direct field getter.
        return getExecThread().isDone();
    }

    /**
     *
     */
    protected boolean
    finalCheck()
    {
        if (LOG_TRANSFORMATIONS) {
            // log the list
            for (int x = 0; x < fCheckedTransformers.size(); x++ ) {
                System.out.println(x + "\t\t" + fCheckedTransformers.get(x));
            }
            System.out.println();
            System.out.println();

            // check for multiples
            for (int x = 0; x < fCheckedTransformers.size(); x++ ) {
                Object current = fCheckedTransformers.get(x);
                for ( int y = x + 1; y < fCheckedTransformers.size(); y++) {
                    Object running = fCheckedTransformers.get(y);
                    if ( current.equals(running) ) {
                        System.out.println(x + "\t" + y + " \t" + "FOUND DUPLICATE: " + current);
                    }
                }
            }
        }

        for (int j = 1; j < fCheckedTransformers.size(); j++) {
            ThreadTransformer transformer = (ThreadTransformer)fCheckedTransformers.get(j);
            for (int i = 0; i < j; i++) {
                ThreadTransformer currTrans = (ThreadTransformer)fCheckedTransformers.get(i);
                assertTrue(currTrans + " incorrectly appeared before " +
                           transformer + " i=" + i + " j=" + j + " size=" +
                           fCheckedTransformers.size(),
                           !(
                             currTrans.getThread().equals(transformer.getThread()) &&
                             currTrans.getIndex() > transformer.getIndex()));
            }
        }
        return true;
    }

    /**
     *
     */
    protected void
    setUp()
        throws Exception
    {
        super.setUp();

        fFinished = 0;
        assertTrue(MIN_TRANS < MAX_TRANS);
        fInstrumentation = InstrumentationHandoff.getInstrumentationOrThrow();
    }

    /**
     *
     */
    protected void
    tearDown()
        throws Exception
    {
        super.tearDown();
    }



    /**
     * Method executeTransform.
     */
    private void
    executeTransform()
    {
        try
        {
            ClassDefinition cd = new ClassDefinition(DummyClass.class, fDummyClassBytes);

            // When the ClassDefinition above is created for the first
            // time and every time redefineClasses() below is called,
            // the transform() function is called for each registered
            // transformer. We only want one complete set of calls to
            // be logged in the fCheckedTransformers Vector so we clear
            // any calls logged for ClassDefinition above and just use
            // the ones logged for redefineClasses() below.
            fCheckedTransformers.clear();

            getInstrumentation().redefineClasses(new ClassDefinition[]{ cd });
        }
        catch (ClassNotFoundException e)
        {
            fail("Could not find the class: "+DummyClass.class.getName());
        }
        catch (UnmodifiableClassException e)
        {
            fail("Could not modify the class: "+DummyClass.class.getName());
        }
    }

    /**
     * Method addTransformerToManager.
     * @param threadTransformer
     */
    private void
    addTransformerToManager(ThreadTransformer threadTransformer)
    {
        getInstrumentation().addTransformer(threadTransformer);
        fAddedTransformers.add(threadTransformer);
    }

    /**
     * Method checkInTransformer.
     * @param myClassFileTransformer
     */
    private void
    checkInTransformer(ThreadTransformer transformer)
    {
        fCheckedTransformers.add(transformer);
    }

    /**
     * Method createTransformer.
     * @param transformerThread
     * @param i
     * @return ThreadTransformer
     */
    private ThreadTransformer
    createTransformer(TransformerThread thread, int index)
    {
        ThreadTransformer tt = null;

        tt = new ThreadTransformer(thread, index);

        return tt;
    }


    protected class
    ExecuteTransformersThread
        extends Thread
    {
        private boolean fDone = false;

        // Effective Java - Item 48: Synchronize access to shared mutable data
        // Provide a synchronized getter.
        private synchronized boolean isDone() {
            return fDone;
        }

        // Effective Java - Item 48: Synchronize access to shared mutable data
        // Provide a synchronized setter.
        private synchronized void setIsDone() {
            fDone = true;
        }

        public void
        run()
        {
            while(!threadsDone())
            {
                executeTransform();
            }

            // Do a final check for good measure
            executeTransform();
            // Effective Java - Item 48: Synchronize access to shared mutable data
            // Don't use direct field setter.
            setIsDone();
        }
    }


    protected class
    TransformerThread
        extends Thread
    {
        private final ThreadTransformer[] fThreadTransformers;

        TransformerThread(String name, int numTransformers)
        {
            super(name);

            fThreadTransformers = makeTransformers(numTransformers);
        }

        /**
         * Method makeTransformers.
         * @param numTransformers
         * @return ThreadTransformer[]
         */
        private ThreadTransformer[]
        makeTransformers(int numTransformers)
        {
            ThreadTransformer[] trans = new ThreadTransformer[numTransformers];

            for (int i = 0; i < trans.length; i++)
            {
                trans[i] = createTransformer(TransformerThread.this, i);
            }

            return trans;
        }

        public void
        run()
        {
            for (int i = 0; i < fThreadTransformers.length; i++)
            {
                addTransformerToManager(fThreadTransformers[i]);
            }
            threadFinished(TransformerThread.this);
        }
    }

    /**
     * ClassFileTransformer implementation that knows its thread
     */
    protected class
    ThreadTransformer extends SimpleIdentityTransformer
    {
        private final String    fName;
        private final int       fIndex;
        private final Thread    fThread;

        /**
         * Constructor for ThreadTransformer.
         */
        public ThreadTransformer(Thread thread, int index) {
            super();
            fThread = thread;
            fIndex = index;
            fName = "TT["+fThread.getName()+"]["+prettyNum(fIndex,3)+"]";
        }

        public String toString()
        {
            return fName;
        }

        /**
         *
         */
        public byte[]
        transform(
            ClassLoader loader,
            String className,
            Class<?> classBeingRedefined,
            ProtectionDomain domain,
            byte[] classfileBuffer)
        {
            if ( className.equals(TransformerManagementThreadAddTests.this.fDummyClassName) ) {
                checkInTransformer(ThreadTransformer.this);
            }
            return super.transform(    loader,
                                        className,
                                        classBeingRedefined,
                                        domain,
                                        classfileBuffer);
        }

        /**
         * Returns the index.
         * @return int
         */
        public int getIndex()
        {
            return fIndex;
        }

        /**
         * Returns the thread.
         * @return Thread
         */
        public Thread getThread()
        {
            return fThread;
        }

    }

    /**
     * DEBUG STUFF
     */
    private int NUM_SWITCHES;

    /**
     * Method printTransformers.
     */
    protected void printTransformers()
    {
        NUM_SWITCHES = 0;
        Iterator trans = fCheckedTransformers.iterator();
        ThreadTransformer old = null;
        StringBuffer buf = new StringBuffer();

        for (int i = 1; trans.hasNext(); i++)
        {
            ThreadTransformer t = (ThreadTransformer)trans.next();
            buf.append(t.toString());
            if (old != null)
            {
                if (!old.getThread().equals(t.getThread()))
                {
                    NUM_SWITCHES++;
                    buf.append("*");
                }
                else
                { buf.append(" "); }
            }
            else
            { buf.append(" "); }

            if (i % 5 == 0)
            {
                buf.append("\n");
            }
            else
            { buf.append(" "); }

            old = t;
        }
        System.out.println(buf);
        System.out.println("\nNumber of transitions from one thread to another: "+NUM_SWITCHES);
    }

    protected String
    prettyNum(int n, int numSize)
    {
        StringBuffer num = new StringBuffer(Integer.toString(n));
        int size = num.length();
        for (int i = 0; i < numSize - size; i++)
        {
            num.insert(0, "0");
        }

        return num.toString();
    }
    /**
     * END DEBUG STUFF
     */

}