ClassLoadingController.java

/*
 * Copyright (c) 2003, 2018, 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.
 */

package nsk.monitoring.share;

import java.util.*;
import nsk.share.log.Log;
import nsk.share.ClassUnloader;
import nsk.share.CustomClassLoader;
import nsk.share.test.Stresser;

/**
 * The <code>ClassLoadingController</code> class allows to operate class
 * loading/unloading process.
 */
public class ClassLoadingController extends StateControllerBase {
        // Path and name of the classes to load
        private static final String CLASSNAME_PATTERN = "nsk.monitoring.share.newclass.LoadableClass";

        private int loadedClassCount = 100;
        private int loaderCount = 1;
        private boolean singleClass = true;
        private String classDir;
        private Hashtable<String, String[]> classesTable = new Hashtable<String, String[]>();
        private ClassUnloader[] unloaders;

        private Stresser stresser;

        /**
         * Constructs a new <code>ClassLoadingController</code> with defined
         * arguments.
         *
         * @param log <code>Log</code> to print log info to.
         * @param loadedClassCount number of classes to load.
         * @param loaderCount number of loaders to use.
         * @param singleClass if class loaders are instances of the same class.
         * @param classDir directory to load classes from.
         */
        public ClassLoadingController(
                Log log,
                int loadedClassCount,
                int loaderCount,
                boolean singleClass,
                String classDir,
                Stresser stresser
        ) {
                super(log);
                setLoadedClassCount(loadedClassCount);
                setLoaderCount(loaderCount);
                setClassDir(classDir);
                singleClassLoaderClass(singleClass);
                dump();
                preloadAllClasses();
                setStresser(stresser);
        }

    private void setStresser(Stresser stresser) {
        this.stresser = stresser;
    }

    public ClassLoadingController(Log log, ArgumentHandler argHandler, Stresser stresser) {
                this(
                        log,
                        argHandler.getLoadableClassesCount(),
//                        argHandler.getLoadersCount(),
                        (int)stresser.getMaxIterations(),
                        argHandler.singleClassloaderClass(),
                        argHandler.getRawArgument(0),
                        stresser
                );
        }

        public void dump() {
                log.debug("classes to be loaded:\t" + loadedClassCount);
                log.debug("classloader instances:\t" + loaderCount);
                if (singleClass)
                        log.debug("classloader class:\tsingle");
                else
                        log.debug("classloader class:\ttwo");
                log.debug("Class dir" + classDir);

        }

        private void setLoadedClassCount(int loadedClassCount) {
                this.loadedClassCount = loadedClassCount;
        }

        // Set loaderCount value
        private void setLoaderCount(int loaderCount) {
                this.loaderCount = loaderCount;
        }

        // Set singleClass value
        private void singleClassLoaderClass(boolean singleClass) {
                this.singleClass = singleClass;
        }

        // Set classDir value
        private void setClassDir(String classDir) {
                this.classDir = classDir;
        }

        // Load classes
        private void preloadAllClasses() {
                log.debug("preloading all classes...");
                if (singleClass)
                        createUnloaders(1);
                else
                        createUnloaders(2);

                for (int i = 0; i < unloaders.length; i++) {
                        loadClasses(unloaders[i], 1, false);
                        unloaders[i].unloadClass();
                }
        }

        // Load classes
        private boolean loadClasses(ClassUnloader unloader, int classCount, boolean doKeep) {
                String newClassName;
                String[] classNames = new String[classCount + 1];
                classNames[0] = unloader.getClassLoader().getClass().getName()
                        + "@"
                        + Integer.toHexString(
                                        unloader.getClassLoader().hashCode()
                                        );


                for (int i = 1; i <= classCount; i++) {
                        newClassName = CLASSNAME_PATTERN + int2Str(i);
                        classNames[i] = newClassName;
                        try {
                                unloader.loadClass(newClassName);
                        } catch (ClassNotFoundException e) {
                                log.error(e.toString());
                                e.printStackTrace();
                                return false;
                        }
                }
                if (doKeep)
                        classesTable.put(String.valueOf(unloader.hashCode()), classNames);
                return true;
        } // loadClasses()

        /**
         * Loads all classes.
         *
         * @see ClassLoadingController#ClassLoadingController
         */
        public int loadClasses() {
                CustomClassLoader loader;
                boolean res = true;
                String loaderName;

                createUnloaders(loaderCount);

                int count = 0;
                for (int i = 0; i < unloaders.length; i++) {
                        loaderName = unloaders[i].getClassLoader().getClass().getName()
                                + "@"
                                + Integer.toHexString(
                                                unloaders[i].getClassLoader().hashCode()
                                                );
                        if (loadClasses(unloaders[i], loadedClassCount, true)) {
                                String[] values = (String[])
                                        classesTable.get(String.valueOf(unloaders[i].hashCode()));
                                int length = values.length - 1;
                                log.debug(loaderName + "(" + i + ")>>> " + length
                                                + " classes have been loaded");
                                count += length;
                        }
                }
                log.info("Total: loading is performed " + count + " times");

                return count;
        }

        // Unload classes
        public int unloadClasses() {
                String loaderName;
                int count = 0;
                long timeLeft = 0;

                for (int i = 0; i < loaderCount && (timeLeft = stresser.getTimeLeft()/1000) > 0; i++) {
                        loaderName = unloaders[i].getClassLoader().getClass().getName()
                                + "@"
                                + Integer.toHexString(
                                                unloaders[i].getClassLoader().hashCode()
                                                );
                        String hashCode = String.valueOf(unloaders[i].hashCode());
                        String[] values = (String[]) classesTable.get(hashCode);

                        if (unloaders[i].unloadClass()) {
                                int length = values.length - 1;
                                count += length;
                                log.debug(loaderName + "(" + i + ")>>> " + length
                                                + " classes have been unloaded (time left: "+timeLeft+" s)");
                                classesTable.remove(hashCode);
                        } else {
                                log.debug(loaderName + "(" + i + ")>>> "
                                                + "classes couldn't be unloaded (time left: "+timeLeft+" s)");
                        }
                }

                log.info("Total: unloading is performed " + count + " times");

                return count;
        }

        private void createUnloaders(int count) {
                CustomClassLoader loader;
                unloaders = new ClassUnloader[count];

                for (int i = 0; i < count; i++) {
                        unloaders[i] = new ClassUnloader();
                        if (singleClass) {
                                loader = unloaders[i].createClassLoader();
                        } else {
                                if (i%2 == 0)
                                        loader = new ClassLoaderA();
                                else
                                        loader = new ClassLoaderB();
                                unloaders[i].setClassLoader(loader);
                        }
                        loader.setClassPath(classDir);
                } // for
        }

        /**
         * Brings out VM into defined state. The method loads all classes via
         * {@link ClassLoadingController#loadClasses}.
         *
         * @see ClassLoadingController#loadClasses
         */
        public void run() {
                loadClasses();
        }

        /**
         * Tries to reclaim VM into initial state. The method tries to load all
         * classes via {@link ClassLoadingController#unloadClasses}.
         *
         * @see ClassLoadingController#unloadClasses
         */
        public void reset() {
                unloadClasses();
        }

        // The class extends CustomClassLoader with specific implementation of
        // toString() method
        class ClassLoaderA extends CustomClassLoader {
                public ClassLoaderA() {
                        super();
                }

                public String toString() {
                        return "ClassLoaderA";
                }
        } // ClassLoaderA

        // The class extends CustomClassLoader with specific implementation of
        // toString() method
        class ClassLoaderB extends CustomClassLoader {
                public ClassLoaderB() {
                        super();
                }

                public String toString() {
                        return "ClassLoaderB";
                }
        } // ClassLoaderB
}