mirror of
https://github.com/LegacyModdingMC/UniMix.git
synced 2026-11-22 07:22:13 +00:00
Add profiler for reviewing Mixin performance
This commit is contained in:
1 parent
ad79bf9b8a
commit
a29029e7cd
10 files changed
+1081
-75
No files matched your search
@@ -56,6 +56,7 @@ import org.spongepowered.asm.obfuscation.RemapperChain;
|
||||
import org.spongepowered.asm.util.ITokenProvider;
|
||||
import org.spongepowered.asm.util.JavaVersion;
|
||||
import org.spongepowered.asm.util.PrettyPrinter;
|
||||
import org.spongepowered.asm.util.perf.Profiler;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.Sets;
|
||||
@@ -320,6 +321,12 @@ public final class MixinEnvironment implements ITokenProvider {
|
||||
* Enable strict checking for mixin targets
|
||||
*/
|
||||
DEBUG_TARGETS(Option.DEBUG_STRICT, "targets"),
|
||||
|
||||
/**
|
||||
* Enable the performance profiler for all mixin operations (normally it
|
||||
* is only enabled during mixin prepare operations)
|
||||
*/
|
||||
DEBUG_PROFILER(Option.DEBUG_ALL, Inherit.ALLOW_OVERRIDE, "profiler"),
|
||||
|
||||
/**
|
||||
* Dumps the bytecode for the target class to disk when mixin
|
||||
@@ -857,6 +864,11 @@ public final class MixinEnvironment implements ITokenProvider {
|
||||
* Logger
|
||||
*/
|
||||
private static final Logger logger = LogManager.getLogger("mixin");
|
||||
|
||||
/**
|
||||
* Performance profiler
|
||||
*/
|
||||
private static final Profiler profiler = new Profiler();
|
||||
|
||||
/**
|
||||
* The phase for this environment
|
||||
@@ -947,9 +959,10 @@ public final class MixinEnvironment implements ITokenProvider {
|
||||
String codeSource = this.getCodeSource();
|
||||
MixinEnvironment.logger.info("SpongePowered MIXIN Subsystem Version={} Source={} Env={}", version, codeSource, side);
|
||||
|
||||
if (this.getOption(Option.DEBUG_VERBOSE)) {
|
||||
boolean verbose = this.getOption(Option.DEBUG_VERBOSE);
|
||||
if (verbose || this.getOption(Option.DEBUG_EXPORT) || this.getOption(Option.DEBUG_PROFILER)) {
|
||||
PrettyPrinter printer = new PrettyPrinter(32);
|
||||
printer.add("SpongePowered MIXIN (Verbose debugging enabled)").centre().hr();
|
||||
printer.add("SpongePowered MIXIN%s", verbose ? " (Verbose debugging enabled)" : "").centre().hr();
|
||||
printer.kv("Code source", codeSource);
|
||||
printer.kv("Internal Version", version);
|
||||
printer.kv("Java 8 Supported", CompatibilityLevel.JAVA_8.isSupported()).hr();
|
||||
@@ -1359,7 +1372,8 @@ public final class MixinEnvironment implements ITokenProvider {
|
||||
public static void init(Phase phase) {
|
||||
if (MixinEnvironment.currentPhase == Phase.NOT_INITIALISED) {
|
||||
MixinEnvironment.currentPhase = phase;
|
||||
MixinEnvironment.getEnvironment(phase);
|
||||
MixinEnvironment env = MixinEnvironment.getEnvironment(phase);
|
||||
MixinEnvironment.getProfiler().setActive(env.getOption(Option.DEBUG_PROFILER));
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
MixinLogger logSpy = new MixinLogger();
|
||||
@@ -1432,6 +1446,15 @@ public final class MixinEnvironment implements ITokenProvider {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the performance profiler
|
||||
*
|
||||
* @return profiler
|
||||
*/
|
||||
public static Profiler getProfiler() {
|
||||
return MixinEnvironment.profiler;
|
||||
}
|
||||
|
||||
/**
|
||||
* Internal callback
|
||||
*
|
||||
|
||||
@@ -54,6 +54,8 @@ import org.spongepowered.asm.mixin.transformer.ClassInfo.Member.Type;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinInfo.MixinClassNode;
|
||||
import org.spongepowered.asm.util.Annotations;
|
||||
import org.spongepowered.asm.util.ClassSignature;
|
||||
import org.spongepowered.asm.util.perf.Profiler;
|
||||
import org.spongepowered.asm.util.perf.Profiler.Section;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
@@ -576,6 +578,8 @@ public final class ClassInfo extends TreeInfo {
|
||||
}
|
||||
|
||||
private static final Logger logger = LogManager.getLogger("mixin");
|
||||
|
||||
private static final Profiler profiler = MixinEnvironment.getProfiler();
|
||||
|
||||
private static final String JAVA_LANG_OBJECT = "java/lang/Object";
|
||||
|
||||
@@ -711,44 +715,49 @@ public final class ClassInfo extends TreeInfo {
|
||||
* @param classNode Class node to inspect
|
||||
*/
|
||||
private ClassInfo(ClassNode classNode) {
|
||||
this.name = classNode.name;
|
||||
this.superName = classNode.superName != null ? classNode.superName : ClassInfo.JAVA_LANG_OBJECT;
|
||||
this.methods = new HashSet<Method>();
|
||||
this.fields = new HashSet<Field>();
|
||||
this.isInterface = ((classNode.access & Opcodes.ACC_INTERFACE) != 0);
|
||||
this.interfaces = new HashSet<String>();
|
||||
this.access = classNode.access;
|
||||
this.isMixin = classNode instanceof MixinClassNode;
|
||||
this.mixin = this.isMixin ? ((MixinClassNode)classNode).getMixin() : null;
|
||||
Section timer = ClassInfo.profiler.begin(Profiler.ROOT, "class.meta");
|
||||
try {
|
||||
this.name = classNode.name;
|
||||
this.superName = classNode.superName != null ? classNode.superName : ClassInfo.JAVA_LANG_OBJECT;
|
||||
this.methods = new HashSet<Method>();
|
||||
this.fields = new HashSet<Field>();
|
||||
this.isInterface = ((classNode.access & Opcodes.ACC_INTERFACE) != 0);
|
||||
this.interfaces = new HashSet<String>();
|
||||
this.access = classNode.access;
|
||||
this.isMixin = classNode instanceof MixinClassNode;
|
||||
this.mixin = this.isMixin ? ((MixinClassNode)classNode).getMixin() : null;
|
||||
|
||||
this.interfaces.addAll(classNode.interfaces);
|
||||
this.interfaces.addAll(classNode.interfaces);
|
||||
|
||||
for (MethodNode method : classNode.methods) {
|
||||
this.addMethod(method, this.isMixin);
|
||||
}
|
||||
for (MethodNode method : classNode.methods) {
|
||||
this.addMethod(method, this.isMixin);
|
||||
}
|
||||
|
||||
boolean isProbablyStatic = true;
|
||||
String outerName = classNode.outerClass;
|
||||
for (FieldNode field : classNode.fields) {
|
||||
if ((field.access & Opcodes.ACC_SYNTHETIC) != 0) {
|
||||
if (field.name.startsWith("this$")) {
|
||||
isProbablyStatic = false;
|
||||
if (outerName == null) {
|
||||
outerName = field.desc;
|
||||
if (outerName != null && outerName.startsWith("L")) {
|
||||
outerName = outerName.substring(1, outerName.length() - 1);
|
||||
boolean isProbablyStatic = true;
|
||||
String outerName = classNode.outerClass;
|
||||
for (FieldNode field : classNode.fields) {
|
||||
if ((field.access & Opcodes.ACC_SYNTHETIC) != 0) {
|
||||
if (field.name.startsWith("this$")) {
|
||||
isProbablyStatic = false;
|
||||
if (outerName == null) {
|
||||
outerName = field.desc;
|
||||
if (outerName != null && outerName.startsWith("L")) {
|
||||
outerName = outerName.substring(1, outerName.length() - 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.fields.add(new Field(field, this.isMixin));
|
||||
}
|
||||
|
||||
this.fields.add(new Field(field, this.isMixin));
|
||||
this.isProbablyStatic = isProbablyStatic;
|
||||
this.outerName = outerName;
|
||||
this.methodMapper = new MethodMapper(MixinEnvironment.getCurrentEnvironment(), this);
|
||||
this.signature = ClassSignature.ofLazy(classNode);
|
||||
} finally {
|
||||
timer.end();
|
||||
}
|
||||
|
||||
this.isProbablyStatic = isProbablyStatic;
|
||||
this.outerName = outerName;
|
||||
this.methodMapper = new MethodMapper(MixinEnvironment.getCurrentEnvironment(), this);
|
||||
this.signature = ClassSignature.ofLazy(classNode);
|
||||
}
|
||||
|
||||
void addInterface(String iface) {
|
||||
|
||||
@@ -36,6 +36,7 @@ import org.spongepowered.asm.mixin.MixinEnvironment;
|
||||
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
|
||||
import org.spongepowered.asm.mixin.transformer.ClassInfo.Method;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinInfo.MixinMethodNode;
|
||||
import org.spongepowered.asm.util.Counter;
|
||||
|
||||
import com.google.common.base.Strings;
|
||||
|
||||
@@ -43,13 +44,6 @@ import com.google.common.base.Strings;
|
||||
* Maintains method remaps for a target class
|
||||
*/
|
||||
public class MethodMapper {
|
||||
|
||||
/**
|
||||
* Mutable integer
|
||||
*/
|
||||
static class Counter {
|
||||
public int value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Logger
|
||||
|
||||
@@ -64,6 +64,8 @@ import org.spongepowered.asm.util.Bytecode;
|
||||
import org.spongepowered.asm.util.Constants;
|
||||
import org.spongepowered.asm.util.ConstraintParser;
|
||||
import org.spongepowered.asm.util.ConstraintParser.Constraint;
|
||||
import org.spongepowered.asm.util.perf.Profiler;
|
||||
import org.spongepowered.asm.util.perf.Profiler.Section;
|
||||
import org.spongepowered.asm.util.throwables.ConstraintViolationException;
|
||||
import org.spongepowered.asm.util.throwables.InvalidConstraintException;
|
||||
|
||||
@@ -230,6 +232,11 @@ class MixinApplicatorStandard {
|
||||
*/
|
||||
protected final ClassNode targetClass;
|
||||
|
||||
/**
|
||||
* Profiler
|
||||
*/
|
||||
protected final Profiler profiler = MixinEnvironment.getProfiler();
|
||||
|
||||
MixinApplicatorStandard(TargetClassContext context) {
|
||||
this.context = context;
|
||||
this.targetName = context.getClassName();
|
||||
@@ -255,9 +262,11 @@ class MixinApplicatorStandard {
|
||||
}
|
||||
|
||||
for (ApplicatorPass pass : ApplicatorPass.values()) {
|
||||
Section timer = this.profiler.begin("pass", pass.name().toLowerCase());
|
||||
for (MixinTargetContext context : mixinContexts) {
|
||||
this.applyMixin(current = context, pass);
|
||||
}
|
||||
timer.end();
|
||||
}
|
||||
|
||||
for (MixinTargetContext context : mixinContexts) {
|
||||
|
||||
@@ -66,6 +66,8 @@ import org.spongepowered.asm.mixin.transformer.throwables.MixinTargetAlreadyLoad
|
||||
import org.spongepowered.asm.util.Annotations;
|
||||
import org.spongepowered.asm.util.Bytecode;
|
||||
import org.spongepowered.asm.util.launchwrapper.LaunchClassLoaderUtil;
|
||||
import org.spongepowered.asm.util.perf.Profiler;
|
||||
import org.spongepowered.asm.util.perf.Profiler.Section;
|
||||
|
||||
import com.google.common.base.Function;
|
||||
import com.google.common.base.Functions;
|
||||
@@ -677,6 +679,11 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
*/
|
||||
private final transient Logger logger = LogManager.getLogger("mixin");
|
||||
|
||||
/**
|
||||
* Profiler
|
||||
*/
|
||||
private final transient Profiler profiler = MixinEnvironment.getProfiler();
|
||||
|
||||
/**
|
||||
* Parent configuration which declares this mixin
|
||||
*/
|
||||
@@ -875,7 +882,7 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
this.logger.error(message);
|
||||
}
|
||||
|
||||
if (this.plugin == null || suppressPlugin || this.plugin.shouldApplyMixin(targetName, this.className)) {
|
||||
if (this.shouldApplyMixin(suppressPlugin, targetName)) {
|
||||
ClassInfo targetInfo = this.getTarget(targetName, checkPublic);
|
||||
if (targetInfo != null && !outTargets.contains(targetInfo)) {
|
||||
outTargets.add(targetInfo);
|
||||
@@ -885,6 +892,13 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
}
|
||||
}
|
||||
|
||||
private boolean shouldApplyMixin(boolean suppressPlugin, String targetName) {
|
||||
Section pluginTimer = this.profiler.begin("plugin");
|
||||
boolean result = this.plugin == null || suppressPlugin || this.plugin.shouldApplyMixin(targetName, this.className);
|
||||
pluginTimer.end();
|
||||
return result;
|
||||
}
|
||||
|
||||
private ClassInfo getTarget(String targetName, boolean checkPublic) throws InvalidMixinException {
|
||||
ClassInfo targetInfo = ClassInfo.forName(targetName);
|
||||
if (targetInfo == null) {
|
||||
@@ -1121,7 +1135,10 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
*/
|
||||
MixinTargetContext createContextFor(TargetClassContext target) {
|
||||
MixinClassNode classNode = this.getClassNode(ClassReader.EXPAND_FRAMES);
|
||||
return this.type.createPreProcessor(classNode).prepare().createContextFor(target);
|
||||
Section preTimer = this.profiler.begin("pre");
|
||||
MixinTargetContext preProcessor = this.type.createPreProcessor(classNode).prepare().createContextFor(target);
|
||||
preTimer.end();
|
||||
return preProcessor;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1179,7 +1196,9 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
*/
|
||||
public void preApply(String transformedName, ClassNode targetClass) {
|
||||
if (this.plugin != null) {
|
||||
Section pluginTimer = this.profiler.begin("plugin");
|
||||
this.plugin.preApply(transformedName, targetClass, this.className, this);
|
||||
pluginTimer.end();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1188,7 +1207,9 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
*/
|
||||
public void postApply(String transformedName, ClassNode targetClass) {
|
||||
if (this.plugin != null) {
|
||||
Section pluginTimer = this.profiler.begin("plugin");
|
||||
this.plugin.postApply(transformedName, targetClass, this.className, this);
|
||||
pluginTimer.end();
|
||||
}
|
||||
|
||||
this.parent.postApply(transformedName, targetClass);
|
||||
|
||||
+55
-15
@@ -56,6 +56,8 @@ import org.spongepowered.asm.util.Annotations;
|
||||
import org.spongepowered.asm.util.Bytecode;
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
import org.spongepowered.asm.util.Constants;
|
||||
import org.spongepowered.asm.util.perf.Profiler;
|
||||
import org.spongepowered.asm.util.perf.Profiler.Section;
|
||||
import org.spongepowered.asm.util.throwables.SyntheticBridgeException;
|
||||
|
||||
/**
|
||||
@@ -134,6 +136,8 @@ class MixinPreProcessorStandard {
|
||||
|
||||
protected final MixinEnvironment env;
|
||||
|
||||
protected final Profiler profiler = MixinEnvironment.getProfiler();
|
||||
|
||||
private final boolean verboseLogging, strictUnique;
|
||||
|
||||
private boolean prepared, attached;
|
||||
@@ -151,13 +155,15 @@ class MixinPreProcessorStandard {
|
||||
*
|
||||
* @return Prepared classnode
|
||||
*/
|
||||
MixinPreProcessorStandard prepare() {
|
||||
final MixinPreProcessorStandard prepare() {
|
||||
if (this.prepared) {
|
||||
return this;
|
||||
}
|
||||
|
||||
this.prepared = true;
|
||||
|
||||
Section prepareTimer = this.profiler.begin("prepare");
|
||||
|
||||
for (MixinMethodNode mixinMethod : this.classNode.mixinMethods) {
|
||||
Method method = this.mixin.getClassInfo().findMethod(mixinMethod);
|
||||
this.prepareMethod(mixinMethod, method);
|
||||
@@ -167,6 +173,7 @@ class MixinPreProcessorStandard {
|
||||
this.prepareField(mixinField);
|
||||
}
|
||||
|
||||
prepareTimer.end();
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -201,17 +208,21 @@ class MixinPreProcessorStandard {
|
||||
// stub
|
||||
}
|
||||
|
||||
MixinPreProcessorStandard conform(TargetClassContext target) {
|
||||
final MixinPreProcessorStandard conform(TargetClassContext target) {
|
||||
return this.conform(target.getClassInfo());
|
||||
}
|
||||
|
||||
MixinPreProcessorStandard conform(ClassInfo target) {
|
||||
final MixinPreProcessorStandard conform(ClassInfo target) {
|
||||
Section conformTimer = this.profiler.begin("conform");
|
||||
|
||||
for (MixinMethodNode mixinMethod : this.classNode.mixinMethods) {
|
||||
if (mixinMethod.isInjector()) {
|
||||
Method method = this.mixin.getClassInfo().findMethod(mixinMethod, ClassInfo.INCLUDE_ALL);
|
||||
this.conformInjector(target, mixinMethod, method);
|
||||
}
|
||||
}
|
||||
|
||||
conformTimer.end();
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -232,19 +243,27 @@ class MixinPreProcessorStandard {
|
||||
*
|
||||
* @param context mixin target context
|
||||
*/
|
||||
MixinPreProcessorStandard attach(MixinTargetContext context) {
|
||||
final MixinPreProcessorStandard attach(MixinTargetContext context) {
|
||||
if (this.attached) {
|
||||
throw new IllegalStateException("Preprocessor was already attached");
|
||||
}
|
||||
|
||||
this.attached = true;
|
||||
|
||||
Section attachTimer = this.profiler.begin("attach");
|
||||
|
||||
// Perform context-sensitive attachment phase
|
||||
Section timer = this.profiler.begin("methods");
|
||||
this.attachMethods(context);
|
||||
timer = timer.next("fields");
|
||||
this.attachFields(context);
|
||||
|
||||
// Apply transformations to the mixin bytecode
|
||||
timer = timer.next("transform");
|
||||
this.transform(context);
|
||||
timer.end();
|
||||
|
||||
attachTimer.end();
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -637,21 +656,42 @@ class MixinPreProcessorStandard {
|
||||
for (Iterator<AbstractInsnNode> iter = mixinMethod.instructions.iterator(); iter.hasNext();) {
|
||||
AbstractInsnNode insn = iter.next();
|
||||
if (insn instanceof MethodInsnNode) {
|
||||
MethodInsnNode methodNode = (MethodInsnNode)insn;
|
||||
Method method = ClassInfo.forName(methodNode.owner).findMethodInHierarchy(methodNode, SearchType.ALL_CLASSES,
|
||||
ClassInfo.INCLUDE_PRIVATE);
|
||||
if (method != null && method.isRenamed()) {
|
||||
methodNode.name = method.getName();
|
||||
}
|
||||
this.transformMethod((MethodInsnNode)insn);
|
||||
} else if (insn instanceof FieldInsnNode) {
|
||||
FieldInsnNode fieldNode = (FieldInsnNode)insn;
|
||||
Field field = ClassInfo.forName(fieldNode.owner).findField(fieldNode, ClassInfo.INCLUDE_PRIVATE);
|
||||
if (field != null && field.isRenamed()) {
|
||||
fieldNode.name = field.getName();
|
||||
}
|
||||
this.transformField((FieldInsnNode)insn);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void transformMethod(MethodInsnNode methodNode) {
|
||||
Section metaTimer = this.profiler.begin("meta");
|
||||
ClassInfo owner = ClassInfo.forName(methodNode.owner);
|
||||
if (owner == null) {
|
||||
throw new RuntimeException(new ClassNotFoundException(methodNode.owner.replace('/', '.')));
|
||||
}
|
||||
|
||||
Method method = owner.findMethodInHierarchy(methodNode, SearchType.ALL_CLASSES, ClassInfo.INCLUDE_PRIVATE);
|
||||
metaTimer.end();
|
||||
|
||||
if (method != null && method.isRenamed()) {
|
||||
methodNode.name = method.getName();
|
||||
}
|
||||
}
|
||||
|
||||
protected void transformField(FieldInsnNode fieldNode) {
|
||||
Section metaTimer = this.profiler.begin("meta");
|
||||
ClassInfo owner = ClassInfo.forName(fieldNode.owner);
|
||||
if (owner == null) {
|
||||
throw new RuntimeException(new ClassNotFoundException(fieldNode.owner.replace('/', '.')));
|
||||
}
|
||||
|
||||
Field field = owner.findField(fieldNode, ClassInfo.INCLUDE_PRIVATE);
|
||||
metaTimer.end();
|
||||
|
||||
if (field != null && field.isRenamed()) {
|
||||
fieldNode.name = field.getName();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -27,16 +27,10 @@ package org.spongepowered.asm.mixin.transformer;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.Method;
|
||||
import java.text.DecimalFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import java.util.SortedSet;
|
||||
import java.util.TreeSet;
|
||||
import java.util.UUID;
|
||||
import java.util.*;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.apache.commons.io.FileUtils;
|
||||
@@ -68,6 +62,8 @@ import org.spongepowered.asm.mixin.transformer.throwables.MixinTransformerError;
|
||||
import org.spongepowered.asm.transformers.TreeTransformer;
|
||||
import org.spongepowered.asm.util.Constants;
|
||||
import org.spongepowered.asm.util.PrettyPrinter;
|
||||
import org.spongepowered.asm.util.perf.Profiler;
|
||||
import org.spongepowered.asm.util.perf.Profiler.Section;
|
||||
|
||||
import net.minecraft.launchwrapper.IClassTransformer;
|
||||
import net.minecraft.launchwrapper.Launch;
|
||||
@@ -362,10 +358,12 @@ public class MixinTransformer extends TreeTransformer {
|
||||
if (force || environment.getOption(Option.DEBUG_EXPORT)) {
|
||||
String filter = environment.getOptionValue(Option.DEBUG_EXPORT_FILTER);
|
||||
if (force || filter == null || this.applyFilter(filter, transformedName)) {
|
||||
Section exportTimer = MixinEnvironment.getProfiler().begin("debug.export");
|
||||
File outputFile = this.dumpClass(transformedName.replace('.', '/'), bytes);
|
||||
if (this.decompiler != null) {
|
||||
this.decompiler.decompile(outputFile);
|
||||
}
|
||||
exportTimer.end();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -435,6 +433,11 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* Postprocessor for passthrough
|
||||
*/
|
||||
private final MixinPostProcessor postProcessor;
|
||||
|
||||
/**
|
||||
* Profiler
|
||||
*/
|
||||
private final Profiler profiler;
|
||||
|
||||
/**
|
||||
* Current environment
|
||||
@@ -478,6 +481,8 @@ public class MixinTransformer extends TreeTransformer {
|
||||
|
||||
this.generators.add(ArgsClassGenerator.getInstance());
|
||||
this.generators.add(InnerClassGenerator.getInstance());
|
||||
|
||||
this.profiler = MixinEnvironment.getProfiler();
|
||||
}
|
||||
|
||||
private IHotSwap initHotSwapper() {
|
||||
@@ -527,6 +532,105 @@ public class MixinTransformer extends TreeTransformer {
|
||||
auditLogger.error("Could not force-load " + target, ex);
|
||||
}
|
||||
}
|
||||
|
||||
if (MixinEnvironment.getCurrentEnvironment().getOption(Option.DEBUG_PROFILER)) {
|
||||
this.printProfilerSummary();
|
||||
}
|
||||
}
|
||||
|
||||
private void printProfilerSummary() {
|
||||
DecimalFormat threedp = new DecimalFormat("(###0.000");
|
||||
DecimalFormat onedp = new DecimalFormat("(###0.0");
|
||||
PrettyPrinter printer = this.profiler.printer(false, true);
|
||||
|
||||
long prepareTime = this.profiler.get("mixin.prepare").getTotalTime();
|
||||
long readTime = this.profiler.get("mixin.read").getTotalTime();
|
||||
long applyTime = this.profiler.get("mixin.apply").getTotalTime();
|
||||
long writeTime = this.profiler.get("mixin.write").getTotalTime();
|
||||
long totalMixinTime = this.profiler.get("mixin").getTotalTime();
|
||||
|
||||
long loadTime = this.profiler.get("class.load").getTotalTime();
|
||||
long transformTime = this.profiler.get("class.transform").getTotalTime();
|
||||
long actualTime = totalMixinTime - loadTime - transformTime;
|
||||
double timeSliceMixin = ((double)actualTime / (double)totalMixinTime) * 100.0D;
|
||||
double timeSliceLoad = ((double)loadTime / (double)totalMixinTime) * 100.0D;
|
||||
double timeSliceTransform = ((double)transformTime / (double)totalMixinTime) * 100.0D;
|
||||
|
||||
long worstTransformerTime = 0L;
|
||||
Section worstTransformer = null;
|
||||
|
||||
for (Section section : this.profiler.getSections()) {
|
||||
long transformerTime = section.getName().startsWith("class.transform.") ? section.getTotalTime() : 0L;
|
||||
if (transformerTime > worstTransformerTime) {
|
||||
worstTransformerTime = transformerTime;
|
||||
worstTransformer = section;
|
||||
}
|
||||
}
|
||||
|
||||
printer.hr().add("Summary").hr().add();
|
||||
|
||||
String format = "%9d ms %12s seconds)";
|
||||
printer.kv("Total mixin time", format, totalMixinTime, threedp.format(totalMixinTime * 0.001)).add();
|
||||
printer.kv("Preparing mixins", format, prepareTime, threedp.format(prepareTime * 0.001));
|
||||
printer.kv("Reading input", format, readTime, threedp.format(readTime * 0.001));
|
||||
printer.kv("Applying mixins", format, applyTime, threedp.format(applyTime * 0.001));
|
||||
printer.kv("Writing output", format, writeTime, threedp.format(writeTime * 0.001)).add();
|
||||
|
||||
printer.kv("of which","");
|
||||
printer.kv("Time spent loading from disk", format, loadTime, threedp.format(loadTime * 0.001));
|
||||
printer.kv("Time spent transforming classes", format, transformTime, threedp.format(transformTime * 0.001)).add();
|
||||
|
||||
if (worstTransformer != null) {
|
||||
printer.kv("Worst transformer", worstTransformer.getName());
|
||||
printer.kv("Class", worstTransformer.getInfo());
|
||||
printer.kv("Time spent", "%s seconds", worstTransformer.getTotalSeconds());
|
||||
printer.kv("called", "%d times", worstTransformer.getTotalCount()).add();
|
||||
}
|
||||
|
||||
printer.kv(" Time allocation: Processing mixins", "%9d ms %10s%% of total)", actualTime, onedp.format(timeSliceMixin));
|
||||
printer.kv("Loading classes", "%9d ms %10s%% of total)", loadTime, onedp.format(timeSliceLoad));
|
||||
printer.kv("Running transformers", "%9d ms %10s%% of total)", transformTime, onedp.format(timeSliceTransform));
|
||||
printer.add();
|
||||
|
||||
try {
|
||||
Class<?> agent = Class.forName("org.spongepowered.metronome.Agent", false, Launch.class.getClassLoader());
|
||||
Method mdGetTimes = agent.getDeclaredMethod("getTimes");
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
Map<String, Long> times = (Map<String, Long>)mdGetTimes.invoke(null);
|
||||
|
||||
printer.hr().add("Transformer Times").hr().add();
|
||||
|
||||
int longest = 10;
|
||||
for (Entry<String, Long> entry : times.entrySet()) {
|
||||
longest = Math.max(longest, entry.getKey().length());
|
||||
}
|
||||
|
||||
for (Entry<String, Long> entry : times.entrySet()) {
|
||||
String name = entry.getKey();
|
||||
long mixinTime = 0L;
|
||||
for (Section section : this.profiler.getSections()) {
|
||||
if (name.equals(section.getInfo())) {
|
||||
mixinTime = section.getTotalTime();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (mixinTime > 0L) {
|
||||
printer.add("%-" + longest + "s %8s ms %8s ms in mixin)", name, entry.getValue() + mixinTime, "(" + mixinTime);
|
||||
} else {
|
||||
printer.add("%-" + longest + "s %8s ms", name, entry.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
printer.add();
|
||||
|
||||
} catch (Throwable th) {
|
||||
// Metronome agent not loaded
|
||||
}
|
||||
|
||||
|
||||
printer.print();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
@@ -541,7 +645,9 @@ public class MixinTransformer extends TreeTransformer {
|
||||
|
||||
if (basicClass == null) {
|
||||
for (IClassGenerator generator : this.generators) {
|
||||
Section genTimer = this.profiler.begin("generator.", generator.getClass().getSimpleName().toLowerCase());
|
||||
if ((basicClass = generator.generate(transformedName)) != null) {
|
||||
genTimer.end();
|
||||
this.exporter.export(transformedName.replace('.', '/'), false, basicClass);
|
||||
return basicClass;
|
||||
}
|
||||
@@ -552,19 +658,23 @@ public class MixinTransformer extends TreeTransformer {
|
||||
boolean locked = this.lock.push().check();
|
||||
|
||||
MixinEnvironment environment = MixinEnvironment.getCurrentEnvironment();
|
||||
|
||||
Section mixinTimer = this.profiler.begin("mixin");
|
||||
|
||||
if (!locked) {
|
||||
try {
|
||||
this.checkSelect(environment);
|
||||
} catch (Exception ex) {
|
||||
this.lock.pop();
|
||||
mixinTimer.end();
|
||||
throw new MixinException(ex);
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
if (this.postProcessor.canTransform(transformedName)) {
|
||||
Section postTimer = this.profiler.begin("postprocessor");
|
||||
byte[] bytes = this.postProcessor.transform(name, transformedName, basicClass);
|
||||
postTimer.end();
|
||||
this.exporter.export(transformedName, false, bytes);
|
||||
return bytes;
|
||||
}
|
||||
@@ -605,8 +715,10 @@ public class MixinTransformer extends TreeTransformer {
|
||||
|
||||
try {
|
||||
// Tree for target class
|
||||
Section timer = this.profiler.begin("read");
|
||||
ClassNode targetClassNode = this.readClass(basicClass, true);
|
||||
TargetClassContext context = new TargetClassContext(this.sessionId, transformedName, targetClassNode, mixins);
|
||||
timer.end();
|
||||
basicClass = this.applyMixins(context);
|
||||
this.transformedCount++;
|
||||
} catch (InvalidMixinException th) {
|
||||
@@ -622,6 +734,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
throw new MixinTransformerError("An unexpected critical error was encountered", th);
|
||||
} finally {
|
||||
this.lock.pop();
|
||||
mixinTimer.end();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -662,20 +775,34 @@ public class MixinTransformer extends TreeTransformer {
|
||||
}
|
||||
String action = this.currentEnvironment == environment ? "Checking for additional" : "Preparing";
|
||||
MixinTransformer.logger.log(this.verboseLoggingLevel, "{} mixins for {}", action, environment);
|
||||
long startTime = System.currentTimeMillis();
|
||||
|
||||
this.profiler.setActive(true);
|
||||
this.profiler.mark(environment.getPhase().toString() + ":prepare");
|
||||
Section prepareTimer = this.profiler.begin("prepare");
|
||||
|
||||
this.selectConfigs(environment);
|
||||
this.selectModules(environment);
|
||||
int totalMixins = this.prepareConfigs(environment);
|
||||
this.currentEnvironment = environment;
|
||||
this.transformedCount = 0;
|
||||
|
||||
prepareTimer.end();
|
||||
|
||||
double elapsedTime = (System.currentTimeMillis() - startTime) * 0.001D;
|
||||
long elapsedMs = prepareTimer.getTime();
|
||||
double elapsedTime = prepareTimer.getSeconds();
|
||||
if (elapsedTime > 0.25D) {
|
||||
long loadTime = this.profiler.get("class.load").getTime();
|
||||
long transformTime = this.profiler.get("class.transform").getTime();
|
||||
long pluginTime = this.profiler.get("mixin.plugin").getTime();
|
||||
String elapsed = new DecimalFormat("###0.000").format(elapsedTime);
|
||||
String perMixinTime = new DecimalFormat("###0.0").format((elapsedTime / totalMixins) * 1000.0);
|
||||
MixinTransformer.logger.log(this.verboseLoggingLevel, "Prepared {} mixins in {} sec ({} msec avg.)", totalMixins, elapsed, perMixinTime);
|
||||
String perMixinTime = new DecimalFormat("###0.0").format(((double)elapsedMs) / totalMixins);
|
||||
|
||||
MixinTransformer.logger.log(this.verboseLoggingLevel, "Prepared {} mixins in {} sec ({}ms avg) ({}ms load, {}ms transform, {}ms plugin)",
|
||||
totalMixins, elapsed, perMixinTime, loadTime, transformTime, pluginTime);
|
||||
}
|
||||
|
||||
this.profiler.mark(environment.getPhase().toString() + ":apply");
|
||||
this.profiler.setActive(environment.getOption(Option.DEBUG_PROFILER));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -801,8 +928,11 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @return class bytecode after application of mixins
|
||||
*/
|
||||
private byte[] applyMixins(TargetClassContext context) {
|
||||
Section timer = this.profiler.begin("preapply");
|
||||
this.preApply(context);
|
||||
timer = timer.next("apply");
|
||||
this.apply(context);
|
||||
timer = timer.next("postapply");
|
||||
try {
|
||||
this.postApply(context);
|
||||
} catch (ValidationFailedException ex) {
|
||||
@@ -812,6 +942,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
this.writeClass(context);
|
||||
}
|
||||
}
|
||||
timer.end();
|
||||
return this.writeClass(context);
|
||||
}
|
||||
|
||||
@@ -927,7 +1058,9 @@ public class MixinTransformer extends TreeTransformer {
|
||||
|
||||
private byte[] writeClass(String transformedName, ClassNode targetClass, boolean forceExport) {
|
||||
// Collapse tree to bytes
|
||||
Section writeTimer = this.profiler.begin("write");
|
||||
byte[] bytes = this.writeClass(targetClass);
|
||||
writeTimer.end();
|
||||
this.exporter.export(transformedName, forceExport, bytes);
|
||||
return bytes;
|
||||
}
|
||||
|
||||
@@ -36,6 +36,8 @@ import org.spongepowered.asm.lib.tree.ClassNode;
|
||||
import org.spongepowered.asm.mixin.MixinEnvironment;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinTransformer.ReEntranceState;
|
||||
import org.spongepowered.asm.util.launchwrapper.LaunchClassLoaderUtil;
|
||||
import org.spongepowered.asm.util.perf.Profiler;
|
||||
import org.spongepowered.asm.util.perf.Profiler.Section;
|
||||
|
||||
import net.minecraft.launchwrapper.IClassTransformer;
|
||||
import net.minecraft.launchwrapper.Launch;
|
||||
@@ -87,10 +89,16 @@ abstract class TreeInfo {
|
||||
static byte[] loadClass(String className, boolean runTransformers) throws ClassNotFoundException, IOException {
|
||||
String transformedName = className.replace('/', '.');
|
||||
String name = MixinEnvironment.getCurrentEnvironment().unmap(transformedName);
|
||||
|
||||
Profiler profiler = MixinEnvironment.getProfiler();
|
||||
Section loadTime = profiler.begin(Profiler.ROOT, "class.load");
|
||||
byte[] classBytes = TreeInfo.getClassBytes(name, transformedName);
|
||||
loadTime.end();
|
||||
|
||||
if (runTransformers) {
|
||||
classBytes = TreeInfo.applyTransformers(name, transformedName, classBytes);
|
||||
Section transformTime = profiler.begin(Profiler.ROOT, "class.transform");
|
||||
classBytes = TreeInfo.applyTransformers(name, transformedName, classBytes, profiler);
|
||||
transformTime.end();
|
||||
}
|
||||
|
||||
if (classBytes == null) {
|
||||
@@ -136,7 +144,7 @@ abstract class TreeInfo {
|
||||
* @return class bytecode after processing by all registered transformers
|
||||
* except the excluded transformers
|
||||
*/
|
||||
private static byte[] applyTransformers(String name, String transformedName, byte[] basicClass) {
|
||||
private static byte[] applyTransformers(String name, String transformedName, byte[] basicClass, Profiler profiler) {
|
||||
if (LaunchClassLoaderUtil.forClassLoader(Launch.classLoader).isClassExcluded(name, transformedName)) {
|
||||
return basicClass;
|
||||
}
|
||||
@@ -149,15 +157,19 @@ abstract class TreeInfo {
|
||||
TreeInfo.lock.clear();
|
||||
}
|
||||
|
||||
Class<? extends IClassTransformer> clazz = transformer.getClass();
|
||||
Section transformTime = profiler.begin(Profiler.ROOT | Profiler.FINE, "class.transform", clazz.getSimpleName().toLowerCase());
|
||||
transformTime.setInfo(clazz.getName());
|
||||
basicClass = transformer.transform(name, transformedName, basicClass);
|
||||
|
||||
transformTime.end();
|
||||
|
||||
if (TreeInfo.lock != null && TreeInfo.lock.isSet()) {
|
||||
// Also add it to the exclusion list so we can exclude it if the environment triggers a rebuild
|
||||
environment.addTransformerExclusion(transformer.getClass().getName());
|
||||
environment.addTransformerExclusion(clazz.getName());
|
||||
|
||||
TreeInfo.lock.clear();
|
||||
TreeInfo.logger.info("A re-entrant transformer '{}' was detected and will no longer process meta class data",
|
||||
transformer.getClass().getName());
|
||||
clazz.getName());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
/*
|
||||
* This file is part of Mixin, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered <https://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.util;
|
||||
|
||||
/**
|
||||
* Mutable integer for use in collections
|
||||
*/
|
||||
public final class Counter {
|
||||
|
||||
/**
|
||||
* Mutable int value
|
||||
*/
|
||||
public int value;
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
return obj != null && obj.getClass() == Counter.class && ((Counter)obj).value == this.value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return this.value;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,718 @@
|
||||
/*
|
||||
* This file is part of Mixin, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered <https://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.util.perf;
|
||||
|
||||
import java.text.DecimalFormat;
|
||||
import java.util.*;
|
||||
|
||||
import org.spongepowered.asm.util.PrettyPrinter;
|
||||
import org.spongepowered.asm.util.PrettyPrinter.Alignment;
|
||||
|
||||
import com.google.common.base.Joiner;
|
||||
|
||||
/**
|
||||
* Performance profiler for Mixin.
|
||||
*/
|
||||
public final class Profiler {
|
||||
|
||||
/**
|
||||
* Flag to indicate a root section. Root sections are always recorded at the
|
||||
* root wherever they occur, but may appear under other sections in order to
|
||||
* show the time share of the root section relative to the parent.
|
||||
*/
|
||||
public static final int ROOT = 0x01;
|
||||
|
||||
/**
|
||||
* Flag to indicate a fine section. Fine sections are always recorded, but
|
||||
* are only displayed in the printed output if the includeFine flag is set.
|
||||
*/
|
||||
public static final int FINE = 0x02;
|
||||
|
||||
/**
|
||||
* Profiler section. Normal sections do nothing so that the profiler itself
|
||||
* consumes minimal resources when disabled.
|
||||
*/
|
||||
public class Section {
|
||||
|
||||
/**
|
||||
* Section name
|
||||
*/
|
||||
private final String name;
|
||||
|
||||
/**
|
||||
* True if this is a FINE section
|
||||
*/
|
||||
private boolean fine;
|
||||
|
||||
/**
|
||||
* Auxilliary info for this section, used for context
|
||||
*/
|
||||
private String info;
|
||||
|
||||
Section(String name) {
|
||||
this.name = name;
|
||||
this.info = name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the delegate (root section) for this section
|
||||
*/
|
||||
Section getDelegate() {
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set this section as FINE
|
||||
*/
|
||||
Section setFine(boolean fine) {
|
||||
this.fine = fine;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether this section is FINE
|
||||
*/
|
||||
public boolean isFine() {
|
||||
return this.fine;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the section name
|
||||
*/
|
||||
public String getName() {
|
||||
return this.name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the base name for this section, for delegated sections this is
|
||||
* the name of the parent section, minus the root
|
||||
*/
|
||||
public String getBaseName() {
|
||||
return this.name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the auxilliary info for this section
|
||||
*
|
||||
* @param info aux info
|
||||
*/
|
||||
public void setInfo(String info) {
|
||||
this.info = info;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the auxilliary info for this section
|
||||
*/
|
||||
public String getInfo() {
|
||||
return this.info;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start timing on this section
|
||||
*
|
||||
* @return fluent
|
||||
*/
|
||||
Section start() {
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop timing of this section
|
||||
*
|
||||
* @return fluent
|
||||
*/
|
||||
protected Section stop() {
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop timing of this section and end it (pop from profiler stack)
|
||||
*
|
||||
* @return fluent
|
||||
*/
|
||||
public Section end() {
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop timing of this section and start a new section at the same level
|
||||
*
|
||||
* @param name name of the next section
|
||||
* @return new section
|
||||
*/
|
||||
public Section next(String name) {
|
||||
this.end();
|
||||
return Profiler.this.begin(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark off a profiling slice in this section. Each timing slice is used
|
||||
* to benchmark a different phase of operations. Calling this method
|
||||
* pushes the current time into the times array and resets the time and
|
||||
* counter to zero
|
||||
*/
|
||||
void mark() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current time in milliseconds in the current phase
|
||||
*/
|
||||
public long getTime() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current time in milliseconds in all phases
|
||||
*/
|
||||
public long getTotalTime() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current time in seconds in the current phase
|
||||
*/
|
||||
public double getSeconds() {
|
||||
return 0.0D;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current time in seconds in all phases
|
||||
*/
|
||||
public double getTotalSeconds() {
|
||||
return 0.0D;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all available time slices including the current one in
|
||||
* milliseconds
|
||||
*/
|
||||
public long[] getTimes() {
|
||||
return new long[1];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of total time periods recorded in the current slice
|
||||
*/
|
||||
public int getCount() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of total time periods recorded in the all slices
|
||||
*/
|
||||
public int getTotalCount() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the average time in milliseconds of each time period recorded in
|
||||
* the current slice
|
||||
*/
|
||||
public double getAverageTime() {
|
||||
return 0.0D;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the average time in milliseconds of each time period recorded in
|
||||
* the all slices
|
||||
*/
|
||||
public double getTotalAverageTime() {
|
||||
return 0.0D;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see java.lang.Object#toString()
|
||||
*/
|
||||
@Override
|
||||
public final String toString() {
|
||||
return this.name;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Live profiler section. Actually records timings for when the profiler is
|
||||
* active.
|
||||
*/
|
||||
class LiveSection extends Section {
|
||||
|
||||
/**
|
||||
* Cursor points at the current active time slice. The current time
|
||||
* slice is not in the array of times.
|
||||
*/
|
||||
private int cursor = 0;
|
||||
|
||||
/**
|
||||
* Historical time slicess (times recorded by calls to {@link #mark})
|
||||
*/
|
||||
private long[] times = new long[0];
|
||||
|
||||
/**
|
||||
* Start time. Zero when not recording a time slice
|
||||
*/
|
||||
private long start = 0L;
|
||||
|
||||
/**
|
||||
* Current accumulated time and time in all previous slices
|
||||
*/
|
||||
private long time, markedTime;
|
||||
|
||||
/**
|
||||
* Current period count and period count in all previous slices
|
||||
*/
|
||||
private int count, markedCount;
|
||||
|
||||
LiveSection(String name, int cursor) {
|
||||
super(name);
|
||||
this.cursor = cursor;
|
||||
}
|
||||
|
||||
@Override
|
||||
Section start() {
|
||||
this.start = System.currentTimeMillis();
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected Section stop() {
|
||||
if (this.start > 0L) {
|
||||
this.time += System.currentTimeMillis() - this.start;
|
||||
}
|
||||
this.start = 0L;
|
||||
this.count++;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Section end() {
|
||||
this.stop();
|
||||
Profiler.this.end(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
void mark() {
|
||||
if (this.cursor >= this.times.length) {
|
||||
this.times = Arrays.copyOf(this.times, this.cursor + 4);
|
||||
}
|
||||
this.times[this.cursor] = this.time;
|
||||
this.markedTime += this.time;
|
||||
this.markedCount += this.count;
|
||||
this.time = 0;
|
||||
this.count = 0;
|
||||
this.cursor++;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getTime() {
|
||||
return this.time;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getTotalTime() {
|
||||
return this.time + this.markedTime;
|
||||
}
|
||||
|
||||
@Override
|
||||
public double getSeconds() {
|
||||
return this.time * 0.001D;
|
||||
}
|
||||
|
||||
@Override
|
||||
public double getTotalSeconds() {
|
||||
return (this.time + this.markedTime) * 0.001D;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long[] getTimes() {
|
||||
long[] times = new long[this.cursor + 1];
|
||||
System.arraycopy(this.times, 0, times, 0, Math.min(this.times.length, this.cursor));
|
||||
times[this.cursor] = this.time;
|
||||
return times;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getCount() {
|
||||
return this.count;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getTotalCount() {
|
||||
return this.count + this.markedCount;
|
||||
}
|
||||
|
||||
@Override
|
||||
public double getAverageTime() {
|
||||
return this.count > 0 ? (double)(this.time) / this.count : 0.0D;
|
||||
}
|
||||
|
||||
@Override
|
||||
public double getTotalAverageTime() {
|
||||
return this.count > 0 ? (double)(this.time + this.markedTime) / (this.count + this.markedCount) : 0.0D;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Sub-profiler-section, acts as a delegate to a root section when recording
|
||||
* a root section under another parent. Calls to methods in this section are
|
||||
* handled locally and in the delegated root.
|
||||
*/
|
||||
class SubSection extends LiveSection {
|
||||
|
||||
/**
|
||||
* Section base name
|
||||
*/
|
||||
private final String baseName;
|
||||
|
||||
/**
|
||||
* Delegated root
|
||||
*/
|
||||
private final Section root;
|
||||
|
||||
SubSection(String name, int cursor, String baseName, Section root) {
|
||||
super(name, cursor);
|
||||
this.baseName = baseName;
|
||||
this.root = root;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getBaseName() {
|
||||
return this.baseName;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setInfo(String info) {
|
||||
this.root.setInfo(info);
|
||||
super.setInfo(info);
|
||||
}
|
||||
|
||||
@Override
|
||||
Section getDelegate() {
|
||||
return this.root;
|
||||
}
|
||||
|
||||
@Override
|
||||
Section start() {
|
||||
this.root.start();
|
||||
return super.start();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Section end() {
|
||||
this.root.stop();
|
||||
return super.end();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Section next(String name) {
|
||||
super.stop();
|
||||
return this.root.next(name);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* All profiler sections
|
||||
*/
|
||||
private final Map<String, Section> sections = new TreeMap<String, Profiler.Section>();
|
||||
|
||||
/**
|
||||
* Profiler phases, recorded by calling {@link #mark}
|
||||
*/
|
||||
private final List<String> phases = new ArrayList<String>();
|
||||
|
||||
/**
|
||||
* Profiler section stack
|
||||
*/
|
||||
private final Deque<Section> stack = new LinkedList<Section>();
|
||||
|
||||
/**
|
||||
* True when profiler is active
|
||||
*/
|
||||
private boolean active;
|
||||
|
||||
public Profiler() {
|
||||
this.phases.add("Initial");
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the active state of the profiler. When activating the profiler is
|
||||
* always reset.
|
||||
*
|
||||
* @param active new active state
|
||||
*/
|
||||
public void setActive(boolean active) {
|
||||
if ((!this.active && active) || !active) {
|
||||
this.reset();
|
||||
}
|
||||
this.active = active;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset all profiler state
|
||||
*/
|
||||
public void reset() {
|
||||
this.sections.clear();
|
||||
this.phases.clear();
|
||||
this.phases.add("Initial");
|
||||
this.stack.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the specified profiler section
|
||||
*
|
||||
* @param name section name
|
||||
* @return profiler section
|
||||
*/
|
||||
public Section get(String name) {
|
||||
Section section = this.sections.get(name);
|
||||
if (section == null) {
|
||||
section = this.active ? new LiveSection(name, this.phases.size() - 1) : new Section(name);
|
||||
this.sections.put(name, section);
|
||||
}
|
||||
|
||||
return section;
|
||||
}
|
||||
|
||||
private Section getSubSection(String name, String baseName, Section root) {
|
||||
Section section = this.sections.get(name);
|
||||
if (section == null) {
|
||||
section = new SubSection(name, this.phases.size() - 1, baseName, root);
|
||||
this.sections.put(name, section);
|
||||
}
|
||||
|
||||
return section;
|
||||
}
|
||||
|
||||
boolean isHead(Section section) {
|
||||
return this.stack.peek() == section;
|
||||
}
|
||||
|
||||
/**
|
||||
* Begin a new profiler section using the specified path
|
||||
*
|
||||
* @param path path parts
|
||||
* @return new profiler section
|
||||
*/
|
||||
public Section begin(String... path) {
|
||||
return this.begin(0, path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Begin a new profiler section using the specified path and flags
|
||||
*
|
||||
* @param flags section flags
|
||||
* @param path path parts
|
||||
* @return new profiler section
|
||||
*/
|
||||
public Section begin(int flags, String... path) {
|
||||
return this.begin(flags, Joiner.on('.').join(path));
|
||||
}
|
||||
|
||||
/**
|
||||
* Begin a new profiler section using the specified name
|
||||
*
|
||||
* @param name section name
|
||||
* @return new profiler section
|
||||
*/
|
||||
public Section begin(String name) {
|
||||
return this.begin(0, name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Begin a new profiler section using the specified name and flags
|
||||
*
|
||||
* @param flags section flags
|
||||
* @param name section name
|
||||
* @return new profiler section
|
||||
*/
|
||||
public Section begin(int flags, String name) {
|
||||
boolean root = (flags & Profiler.ROOT) != 0;
|
||||
boolean fine = (flags & Profiler.FINE) != 0;
|
||||
|
||||
String path = name;
|
||||
Section head = this.stack.peek();
|
||||
if (head != null) {
|
||||
path = head.getName() + (root ? " -> " : ".") + path;
|
||||
}
|
||||
|
||||
Section section = this.get(root ? name : path);
|
||||
if (root && head != null && this.active) {
|
||||
section = this.getSubSection(path, head.getName(), section);
|
||||
}
|
||||
|
||||
section.setFine(fine);
|
||||
this.stack.push(section);
|
||||
return section.start();
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback from section when {@link Section#end} is called, pops the
|
||||
* section from the profiler stack
|
||||
*
|
||||
* @param section section ending
|
||||
*/
|
||||
void end(Section section) {
|
||||
for (Section head = this.stack.pop(), next = head; next != section; next = this.stack.pop()) {
|
||||
if (next == null) {
|
||||
if (head == null) {
|
||||
throw new IllegalStateException("Attempted to pop " + section + " but the stack is empty");
|
||||
}
|
||||
throw new IllegalStateException("Attempted to pop " + section + " which was not in the stack, head was " + head);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark a new phase (time slice) for this profiler, all sections record
|
||||
* their current times and then reset to zero. If no times have been
|
||||
* recorded in the current phase, the phase is discarded.
|
||||
*
|
||||
* @param phase Name of the phase
|
||||
*/
|
||||
public void mark(String phase) {
|
||||
long currentPhaseTime = 0L;
|
||||
for (Section section : this.sections.values()) {
|
||||
currentPhaseTime += section.getTime();
|
||||
}
|
||||
|
||||
// If no accumulated time in the current phase, just discard it
|
||||
if (currentPhaseTime == 0L) {
|
||||
int size = this.phases.size();
|
||||
this.phases.set(size - 1, phase);
|
||||
return;
|
||||
}
|
||||
|
||||
this.phases.add(phase);
|
||||
for (Section section : this.sections.values()) {
|
||||
section.mark();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all recorded profiler sections
|
||||
*/
|
||||
public Collection<Section> getSections() {
|
||||
return Collections.<Section>unmodifiableCollection(this.sections.values());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the profiler state with all sections in a {@link PrettyPrinter}.
|
||||
*
|
||||
* @param includeFine Include sections marked as FINE
|
||||
* @param group Group delegated sections with their root instead of in the
|
||||
* normal alphabetical order
|
||||
* @return PrettyPrinter with section data
|
||||
*/
|
||||
public PrettyPrinter printer(boolean includeFine, boolean group) {
|
||||
PrettyPrinter printer = new PrettyPrinter();
|
||||
|
||||
// 4 extra columns, name, total, count, avg
|
||||
int colCount = this.phases.size() + 4;
|
||||
|
||||
// Which columns go where
|
||||
// Name Total Phases Count Average
|
||||
// | | | | |
|
||||
int[] columns = { 0, 1, 2, colCount - 2, colCount - 1 };
|
||||
|
||||
Object[] headers = new Object[(colCount) * 2];
|
||||
for (int col = 0, pos = 0; col < colCount; col++, pos = col * 2) {
|
||||
headers[pos + 1] = Alignment.RIGHT;
|
||||
if (col == columns[0]) {
|
||||
headers[pos] = (group ? "" : " ") + "Section";
|
||||
headers[pos + 1] = Alignment.LEFT;
|
||||
} else if (col == columns[1]) {
|
||||
headers[pos] = " TOTAL";
|
||||
} else if (col == columns[3]) {
|
||||
headers[pos] = " Count";
|
||||
} else if (col == columns[4]) {
|
||||
headers[pos] = "Avg. ";
|
||||
} else if (col - columns[2] < this.phases.size()) {
|
||||
headers[pos] = this.phases.get(col - columns[2]);
|
||||
} else {
|
||||
headers[pos] = "";
|
||||
}
|
||||
}
|
||||
|
||||
printer.table(headers).th().hr().add();
|
||||
|
||||
for (Section section : this.sections.values()) {
|
||||
if ((section.isFine() && !includeFine) || (group && section.getDelegate() != section)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Add row for this section
|
||||
this.printSectionRow(printer, colCount, columns, section, group);
|
||||
|
||||
// If grouping, print sections which have this section as delegate
|
||||
if (group) {
|
||||
for (Section subSection : this.sections.values()) {
|
||||
Section delegate = subSection.getDelegate();
|
||||
if ((subSection.isFine() && !includeFine) || delegate != section || delegate == subSection) {
|
||||
continue;
|
||||
}
|
||||
|
||||
this.printSectionRow(printer, colCount, columns, subSection, group);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return printer.add();
|
||||
}
|
||||
|
||||
private void printSectionRow(PrettyPrinter printer, int colCount, int[] columns, Section section, boolean group) {
|
||||
boolean isDelegate = section.getDelegate() != section;
|
||||
Object[] values = new Object[colCount];
|
||||
int col = 1;
|
||||
if (group) {
|
||||
values[0] = isDelegate ? " > " + section.getBaseName() : section.getName();
|
||||
} else {
|
||||
values[0] = (isDelegate ? "+ " : " ") + section.getName();
|
||||
}
|
||||
|
||||
long[] times = section.getTimes();
|
||||
for (long time : times) {
|
||||
if (col == columns[1]) {
|
||||
values[col++] = section.getTotalTime() + " ms";
|
||||
}
|
||||
if (col >= columns[2] && col < values.length) {
|
||||
values[col++] = time + " ms";
|
||||
}
|
||||
}
|
||||
|
||||
values[columns[3]] = section.getTotalCount();
|
||||
values[columns[4]] = new DecimalFormat(" ###0.000 ms").format(section.getTotalAverageTime());
|
||||
|
||||
for (int i = 0; i < values.length; i++) {
|
||||
if (values[i] == null) {
|
||||
values[i] = "-";
|
||||
}
|
||||
}
|
||||
|
||||
printer.tr(values);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user