org.adoptopenjdk.jitwatch.optimizedvcall.OptimizedVirtualCallFinder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jitwatch-jarscan-maven-plugin Show documentation
A Maven plugin that scans the project artifact and its dependencies for methods that cannot be inlined by the JIT compiler. It uses the JarScan utility from the JITWatch project to do that. See https://github.com/AdoptOpenJDK/jitwatch .
The newest version!
/*
 * Copyright (c) 2013-2015 Chris Newland.
 * Licensed under https://github.com/AdoptOpenJDK/jitwatch/blob/master/LICENSE-BSD
 * Instructions: https://github.com/AdoptOpenJDK/jitwatch/wiki
 */
package org.adoptopenjdk.jitwatch.optimizedvcall;

import static org.adoptopenjdk.jitwatch.core.JITWatchConstants.DEBUG_LOGGING_OVC;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.adoptopenjdk.jitwatch.model.IMetaMember;
import org.adoptopenjdk.jitwatch.model.IReadOnlyJITDataModel;
import org.adoptopenjdk.jitwatch.model.LogParseException;
import org.adoptopenjdk.jitwatch.model.MemberSignatureParts;
import org.adoptopenjdk.jitwatch.model.MetaClass;
import org.adoptopenjdk.jitwatch.model.assembly.AssemblyBlock;
import org.adoptopenjdk.jitwatch.model.assembly.AssemblyInstruction;
import org.adoptopenjdk.jitwatch.model.assembly.AssemblyMethod;
import org.adoptopenjdk.jitwatch.model.bytecode.BytecodeInstruction;
import org.adoptopenjdk.jitwatch.model.bytecode.ClassBC;
import org.adoptopenjdk.jitwatch.model.bytecode.MemberBytecode;
import org.adoptopenjdk.jitwatch.model.bytecode.SourceMapper;
import org.adoptopenjdk.jitwatch.util.ParseUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class OptimizedVirtualCallFinder
{
	// optimized virtual_call info output by
	// hotspot/src/share/tools/hsdis/vm/code/nmethod.cpp

	private static final Logger logger = LoggerFactory.getLogger(OptimizedVirtualCallFinder.class);

	private IReadOnlyJITDataModel model;
	private List classLocations = new ArrayList<>();

	public OptimizedVirtualCallFinder(IReadOnlyJITDataModel model, List classLocations)
	{
		this.model = model;
		this.classLocations = classLocations;
	}

	public OptimizedVirtualCall findOptimizedCall(AssemblyInstruction instruction)
	{
		if (DEBUG_LOGGING_OVC)
		{
			logger.debug("findOptimizedCall: {}", instruction);
		}

		OptimizedVirtualCall result = null;

		if (instruction != null && instruction.isOptimizedVCall())
		{
			if (DEBUG_LOGGING_OVC)
			{
				logger.debug("Instruction is an OVC");
			}

			VirtualCallSite callSite = instruction.getOptimizedVirtualCallSiteOrNull();

			if (DEBUG_LOGGING_OVC)
			{
				logger.debug("Found callSite: {}", callSite);
			}

			result = getOptimizedVirtualCall(callSite);
		}
		else
		{
			if (DEBUG_LOGGING_OVC)
			{
				logger.debug("Instruction is not an OVC");
			}
		}

		return result;
	}

	public OptimizedVirtualCall getOptimizedVirtualCall(VirtualCallSite callSite)
	{
		OptimizedVirtualCall result = null;

		if (callSite != null)
		{
			BytecodeInstruction bytecodeInstruction = null;

			MemberBytecode memberBytecode = getMemberBytecodeForCallSite(callSite);

			if (DEBUG_LOGGING_OVC)
			{
				logger.debug("VCS: {} found MemberBytecode {}", callSite, memberBytecode != null);
			}

			if (memberBytecode != null)
			{
				IMetaMember callerMember = findMember(memberBytecode.getMemberSignatureParts());

				if (DEBUG_LOGGING_OVC)
				{
					logger.debug("Found member for msp:\n{}\nMember:{}", memberBytecode.getMemberSignatureParts(), callerMember);
				}

				bytecodeInstruction = memberBytecode.getBytecodeAtOffset(callSite.getBytecodeOffset());

				if (DEBUG_LOGGING_OVC)
				{
					logger.debug("Found BytecodeInstruction: {}", bytecodeInstruction);
				}

				if (bytecodeInstruction != null)
				{
					IMetaMember calleeMember = null;

					try
					{
						calleeMember = ParseUtil.getMemberFromBytecodeComment(model, callerMember, bytecodeInstruction);
					}
					catch (LogParseException e)
					{
						logger.error("Could not get member from bytecode comment", e);
					}

					if (DEBUG_LOGGING_OVC)
					{
						logger.debug("=========================");
						logger.debug("callerMember: {}", callerMember);
						logger.debug("calleeMember: {}", calleeMember);
						logger.debug("callSite    : {}", callSite);
						logger.debug("bytecodeInstruction : {}", bytecodeInstruction);
						logger.debug("=========================");
					}

					if (callerMember != null && calleeMember != null)
					{
						result = new OptimizedVirtualCall(callerMember, calleeMember, callSite, bytecodeInstruction);
					}
					else
					{
						logger.error("Could not create OVC from\ncaller: {}\ncallee: {}\nCallSite was: {}", callerMember,
								calleeMember, callSite);
					}
				}
				else
				{
					logger.error("Could not find BytecodeInstruction for VCS: {}", callSite);
				}
			}
		}
		else
		{
			if (DEBUG_LOGGING_OVC)
			{
				logger.warn("Could not find memberBytecode for VCS: {}", callSite);
			}
		}

		return result;
	}

	public IMetaMember findMember(MemberSignatureParts msp)
	{
		IMetaMember result = null;

		String metaClassName = msp.getFullyQualifiedClassName();

		MetaClass metaClass = model.getPackageManager().getMetaClass(metaClassName);

		if (DEBUG_LOGGING_OVC)
		{
			logger.debug("Looking for metaClass: {} found: {}", metaClassName, metaClass);
		}

		if (metaClass != null)
		{
			result = metaClass.getMemberForSignature(msp);
		}

		return result;
	}

	private MemberBytecode getMemberBytecodeForCallSite(VirtualCallSite callSite)
	{
		if (DEBUG_LOGGING_OVC)
		{
			logger.debug("getMemberBytecodeForCallSite({})", callSite);
		}

		MemberBytecode result = null;

		if (callSite != null)
		{
			String callerClass = callSite.getClassName();

			MetaClass metaClass = model.getPackageManager().getMetaClass(callerClass);

			if (DEBUG_LOGGING_OVC)
			{
				logger.debug("Found MetaClass {} for callerClass {}", metaClass, callerClass);
			}

			if (metaClass != null)
			{
				ClassBC classBC = metaClass.getClassBytecode(model, classLocations);

				if (DEBUG_LOGGING_OVC)
				{
					logger.debug("Got ClassBC: {}", classBC != null);
				}

				if (classBC != null)
				{
					result = SourceMapper.getMemberBytecodeForSourceLine(classBC, callSite.getSourceLine());
				}
			}
		}

		if (DEBUG_LOGGING_OVC)
		{
			logger.debug("Got MemberBytecode: {}", result != null);
		}
		return result;
	}

	public List findOptimizedCalls(IMetaMember member)
	{
		if (DEBUG_LOGGING_OVC)
		{
			logger.debug("Looking for OVCs for member: {}", member);
		}

		Set squashDuplicatesSet = new HashSet<>();

		List assemblyMethods = member.getAssemblyMethods();
		
		AssemblyMethod asmMethod = assemblyMethods.get(assemblyMethods.size() - 1);

		if (DEBUG_LOGGING_OVC)
		{
			logger.debug("Member assembly\n{}", asmMethod);
		}

		if (asmMethod != null)
		{
			for (AssemblyBlock block : asmMethod.getBlocks())
			{
				squashDuplicatesSet.addAll(findInstructionsForBlock(member, block));
			}
		}

		List result = new ArrayList<>(squashDuplicatesSet);

		return result;
	}

	public List findInstructionsForBlock(IMetaMember member, AssemblyBlock block)
	{
		List result = new ArrayList<>();

		for (AssemblyInstruction instruction : block.getInstructions())
		{
			OptimizedVirtualCall optimizedVCall = findOptimizedCall(instruction);

			if (optimizedVCall != null && !result.contains(optimizedVCall))
			{
				if (DEBUG_LOGGING_OVC)
				{
					logger.debug("Found OVC {} for member {}", optimizedVCall, member);
				}

				result.add(optimizedVCall);
			}
		}

		return result;
	}
}