/*******************************************************************************
* Copyright (c) 2000, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.core.runtime.internal.stats;
import java.io.*;
import java.net.URL;
import java.util.*;
import org.eclipse.osgi.baseadaptor.HookConfigurator;
import org.eclipse.osgi.baseadaptor.HookRegistry;
import org.eclipse.osgi.baseadaptor.bundlefile.BundleEntry;
import org.eclipse.osgi.baseadaptor.hooks.ClassLoadingStatsHook;
import org.eclipse.osgi.baseadaptor.loader.ClasspathEntry;
import org.eclipse.osgi.baseadaptor.loader.ClasspathManager;
import org.eclipse.osgi.framework.adaptor.BundleWatcher;
import org.eclipse.osgi.framework.adaptor.FrameworkAdaptor;
import org.eclipse.osgi.framework.debug.Debug;
import org.eclipse.osgi.framework.debug.FrameworkDebugOptions;
import org.eclipse.osgi.util.ManifestElement;
import org.osgi.framework.Bundle;
public class StatsManager implements BundleWatcher, HookConfigurator, ClassLoadingStatsHook {
// This connect bundles and their info, and so allows to access the info without running through
// the bundle registry. This map only contains activated bundles. The key is the bundle Id
private Hashtable<Long, BundleStats> bundles = new Hashtable<Long, BundleStats>(20);
private Map<Thread, Stack<BundleStats>> activationStacks = new HashMap<Thread, Stack<BundleStats>>(5);
private static boolean booting = true; // the state of the platform. This value is changed by the InternalPlatform itself.
private static StatsManager defaultInstance;
public static boolean MONITOR_ACTIVATION = false;
public static boolean MONITOR_CLASSES = false;
public static boolean MONITOR_RESOURCES = false;
public static String TRACE_FILENAME = "runtime.traces"; //$NON-NLS-1$
public static String TRACE_FILTERS = "trace.properties"; //$NON-NLS-1$
public static boolean TRACE_CLASSES = false;
public static boolean TRACE_BUNDLES = false;
public static final String FRAMEWORK_SYMBOLICNAME = "org.eclipse.osgi"; //$NON-NLS-1$
//Option names for spies
private static final String OPTION_MONITOR_ACTIVATION = FRAMEWORK_SYMBOLICNAME + "/monitor/activation"; //$NON-NLS-1$
private static final String OPTION_MONITOR_CLASSES = FRAMEWORK_SYMBOLICNAME + "/monitor/classes"; //$NON-NLS-1$
private static final String OPTION_MONITOR_RESOURCES = FRAMEWORK_SYMBOLICNAME + "/monitor/resources"; //$NON-NLS-1$
private static final String OPTION_TRACE_BUNDLES = FRAMEWORK_SYMBOLICNAME + "/trace/activation"; //$NON-NLS-1$
private static final String OPTION_TRACE_CLASSES = FRAMEWORK_SYMBOLICNAME + "/trace/classLoading"; //$NON-NLS-1$
private static final String OPTION_TRACE_FILENAME = FRAMEWORK_SYMBOLICNAME + "/trace/filename"; //$NON-NLS-1$
private static final String OPTION_TRACE_FILTERS = FRAMEWORK_SYMBOLICNAME + "/trace/filters"; //$NON-NLS-1$
static {
setDebugOptions();
}
public static StatsManager getDefault() {
if (defaultInstance == null) {
defaultInstance = new StatsManager();
defaultInstance.initialize();
}
return defaultInstance;
}
public static void setDebugOptions() {
FrameworkDebugOptions options = FrameworkDebugOptions.getDefault();
// may be null if debugging is not enabled
if (options == null)
return;
MONITOR_ACTIVATION = options.getBooleanOption(OPTION_MONITOR_ACTIVATION, false);
MONITOR_CLASSES = options.getBooleanOption(OPTION_MONITOR_CLASSES, false);
MONITOR_RESOURCES = options.getBooleanOption(OPTION_MONITOR_RESOURCES, false);
TRACE_CLASSES = options.getBooleanOption(OPTION_TRACE_CLASSES, false);
TRACE_BUNDLES = options.getBooleanOption(OPTION_TRACE_BUNDLES, false);
TRACE_FILENAME = options.getOption(OPTION_TRACE_FILENAME, TRACE_FILENAME);
TRACE_FILTERS = options.getOption(OPTION_TRACE_FILTERS, TRACE_FILTERS);
}
public static void doneBooting() {
booting = false;
}
public static boolean isBooting() {
return booting;
}
/**
* Returns the result of converting a list of comma-separated tokens into an array
*
* @return the array of string tokens
* @param prop the initial comma-separated string
*/
public static String[] getArrayFromList(String prop) {
return ManifestElement.getArrayFromList(prop, ","); //$NON-NLS-1$
}
private void initialize() {
// add the system bundle
BundleStats bundle = findBundle(FrameworkAdaptor.FRAMEWORK_SYMBOLICNAME, 0);
bundle.setTimestamp(System.currentTimeMillis());
bundle.setActivationOrder(bundles.size());
bundle.setDuringStartup(booting);
}
public void watchBundle(Bundle bundle, int type) {
switch (type) {
case BundleWatcher.START_ACTIVATION :
startActivation(bundle);
break;
case BundleWatcher.END_ACTIVATION :
endActivation(bundle);
break;
}
}
public void startActivation(Bundle bundle) {
// should be called from a synchronized location to protect against concurrent updates
BundleStats info = findBundle(bundle.getSymbolicName(), bundle.getBundleId());
info.setTimestamp(System.currentTimeMillis());
info.setActivationOrder(bundles.size());
info.setDuringStartup(booting);
Stack<BundleStats> activationStack = activationStacks.get(Thread.currentThread());
if (activationStack == null) {
activationStack = new Stack<BundleStats>();
activationStacks.put(Thread.currentThread(), activationStack);
}
// set the parentage of activation
if (activationStack.size() != 0) {
BundleStats activatedBy = activationStack.peek();
activatedBy.activated(info);
info.setActivatedBy(activatedBy);
}
activationStack.push(info);
if (TRACE_BUNDLES == true) {
traceActivate(bundle, info);
}
}
public void endActivation(Bundle symbolicName) {
Stack<BundleStats> activationStack = activationStacks.get(Thread.currentThread());
// should be called from a synchronized location to protect against concurrent updates
BundleStats info = activationStack.pop();
info.endActivation();
}
private void traceActivate(Bundle bundle, BundleStats info) {
try {
PrintWriter output = new PrintWriter(new FileOutputStream(ClassloaderStats.traceFile.getAbsolutePath(), true));
try {
long startPosition = ClassloaderStats.traceFile.length();
output.println("Activating bundle: " + bundle.getSymbolicName()); //$NON-NLS-1$
output.println("Bundle activation stack:"); //$NON-NLS-1$
Stack<BundleStats> activationStack = activationStacks.get(Thread.currentThread());
for (int i = activationStack.size() - 1; i >= 0; i--)
output.println("\t" + activationStack.get(i).getSymbolicName()); //$NON-NLS-1$
output.println("Class loading stack:"); //$NON-NLS-1$
Stack<ClassStats> classStack = ClassloaderStats.getClassStack();
for (int i = classStack.size() - 1; i >= 0; i--)
output.println("\t" + classStack.get(i).getClassName()); //$NON-NLS-1$
output.println("Stack trace:"); //$NON-NLS-1$
new Throwable().printStackTrace(output);
info.setTraceStart(startPosition);
} finally {
output.close();
info.setTraceEnd(ClassloaderStats.traceFile.length());
}
} catch (IOException e) {
e.printStackTrace();
}
}
public BundleStats findBundle(String symbolicName, long id) {
BundleStats result = bundles.get(new Long(id));
try {
if (result == null) {
result = new BundleStats(symbolicName, id);
bundles.put(new Long(id), result);
}
} catch (IllegalAccessError e) {
e.printStackTrace();
}
return result;
}
public BundleStats[] getBundles() {
return bundles.values().toArray(new BundleStats[bundles.size()]);
}
public BundleStats getBundle(long id) {
return bundles.get(new Long(id));
}
/**
* @throws ClassNotFoundException
*/
public void preFindLocalClass(String name, ClasspathManager manager) throws ClassNotFoundException {
if (StatsManager.MONITOR_CLASSES) //Support for performance analysis
ClassloaderStats.startLoadingClass(getClassloaderId(manager), name);
}
public void postFindLocalClass(String name, Class<?> clazz, ClasspathManager manager) {
if (StatsManager.MONITOR_CLASSES)
ClassloaderStats.endLoadingClass(getClassloaderId(manager), name, clazz != null);
}
public void preFindLocalResource(String name, ClasspathManager manager) {
// do nothing
}
public void postFindLocalResource(String name, URL resource, ClasspathManager manager) {
if (StatsManager.MONITOR_RESOURCES)
if (resource != null && name.endsWith(".properties")) //$NON-NLS-1$
ClassloaderStats.loadedBundle(getClassloaderId(manager), new ResourceBundleStats(getClassloaderId(manager), name, resource));
return;
}
public void recordClassDefine(String name, Class<?> clazz, byte[] classbytes, ClasspathEntry classpathEntry, BundleEntry entry, ClasspathManager manager) {
// do nothing
}
private String getClassloaderId(ClasspathManager loader) {
return loader.getBaseData().getSymbolicName();
}
public void addHooks(HookRegistry hookRegistry) {
if (Debug.MONITOR_ACTIVATION)
hookRegistry.addWatcher(StatsManager.getDefault());
if (StatsManager.MONITOR_CLASSES || StatsManager.MONITOR_RESOURCES)
hookRegistry.addClassLoadingStatsHook(StatsManager.getDefault());
}
}