Espresso is a meta-circular Java Virtual Machine (JVM) written in Java that can run Java bytecode. This article provides a comprehensive exploration of Espresso's architecture, implementation, and practical usage.
Understanding Espresso's Architecture
Step 1: Core Concepts and Setup
// Espresso main entry point demonstration
package com.oracle.truffle.espresso;
public class EspressoVM {
private final TruffleLanguage.Env env;
private final Context context;
private final ClassLoader classLoader;
private final EspressoClassRegistry classRegistry;
public EspressoVM(TruffleLanguage.Env env, Context context) {
this.env = env;
this.context = context;
this.classLoader = new EspressoClassLoader();
this.classRegistry = new EspressoClassRegistry();
}
public static void main(String[] args) {
// Bootstrap Espresso VM
EspressoVM vm = createVM();
// Run Java code on Java VM written in Java
vm.executeClass("com.example.Main", args);
}
private void executeClass(String className, String[] args) {
try {
// Load and execute the target class
EspressoClass targetClass = classRegistry.loadClass(className);
Method mainMethod = targetClass.findMethod("main", "([Ljava/lang/String;)V");
if (mainMethod != null) {
// Create arguments array
Object[] mainArgs = { createStringArray(args) };
mainMethod.invoke(null, mainArgs);
}
} catch (EspressoException e) {
System.err.println("Failed to execute class: " + className);
e.printStackTrace();
}
}
}
Step 2: Espresso Class Representation
package com.oracle.truffle.espresso.runtime;
public class EspressoClass {
private final String name;
private final EspressoClass superClass;
private final EspressoClass[] interfaces;
private final Field[] fields;
private final Method[] methods;
private final ClassLoader classLoader;
private final int accessFlags;
private final ConstantPool constantPool;
// Class initialization state
private volatile boolean initialized = false;
private final Object initLock = new Object();
public EspressoClass(String name,
EspressoClass superClass,
EspressoClass[] interfaces,
Field[] fields,
Method[] methods,
ConstantPool constantPool,
int accessFlags,
ClassLoader classLoader) {
this.name = name;
this.superClass = superClass;
this.interfaces = interfaces;
this.fields = fields;
this.methods = methods;
this.constantPool = constantPool;
this.accessFlags = accessFlags;
this.classLoader = classLoader;
}
public Method findMethod(String name, String descriptor) {
for (Method method : methods) {
if (method.getName().equals(name) &&
method.getDescriptor().equals(descriptor)) {
return method;
}
}
// Check superclass
if (superClass != null) {
Method superMethod = superClass.findMethod(name, descriptor);
if (superMethod != null) {
return superMethod;
}
}
// Check interfaces
for (EspressoClass iface : interfaces) {
Method ifaceMethod = iface.findMethod(name, descriptor);
if (ifaceMethod != null) {
return ifaceMethod;
}
}
return null;
}
public void initialize() {
if (initialized) return;
synchronized (initLock) {
if (initialized) return;
// Initialize superclass first
if (superClass != null) {
superClass.initialize();
}
// Run class initializer (<clinit> method)
Method clinit = findMethod("<clinit>", "()V");
if (clinit != null) {
clinit.invoke(null); // Static method, no instance needed
}
initialized = true;
}
}
public Object newInstance() {
initialize(); // Ensure class is initialized
// Allocate memory for instance
Object instance = allocateInstance();
// Run constructor (<init> method)
Method init = findMethod("<init>", "()V");
if (init != null) {
init.invoke(instance);
}
return instance;
}
private native Object allocateInstance();
}
Bytecode Interpretation Engine
Step 3: Bytecode Interpreter Implementation
package com.oracle.truffle.espresso.interpreter;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.espresso.bytecode.BytecodeStream;
import com.oracle.truffle.espresso.runtime.EspressoContext;
import com.oracle.truffle.espresso.runtime.StaticObject;
public class BytecodeInterpreter {
private final EspressoContext context;
private final BytecodeNode rootNode;
public BytecodeInterpreter(EspressoContext context) {
this.context = context;
this.rootNode = new BytecodeRootNode(context.getLanguage());
}
public Object executeMethod(StaticObject receiver,
EspressoMethod method,
Object[] arguments) {
BytecodeStream bytecode = method.getBytecode();
VirtualFrame frame = createFrame(method, receiver, arguments);
return interpretBytecode(frame, bytecode, method);
}
private Object interpretBytecode(VirtualFrame frame,
BytecodeStream bytecode,
EspressoMethod method) {
int bci = 0; // Bytecode index
int[] stack = new int[method.getMaxStack()];
int stackPointer = 0;
Object[] locals = new Object[method.getMaxLocals()];
// Initialize locals with parameters
System.arraycopy(frame.getArguments(), 0, locals, 0, frame.getArguments().length);
while (bci < bytecode.length()) {
int opcode = bytecode.readU1(bci);
switch (opcode) {
case Opcodes.NOP:
bci += 1;
break;
case Opcodes.ACONST_NULL:
stack[stackPointer++] = null;
bci += 1;
break;
case Opcodes.ICONST_0:
stack[stackPointer++] = 0;
bci += 1;
break;
case Opcodes.ICONST_1:
stack[stackPointer++] = 1;
bci += 1;
break;
case Opcodes.LDC:
int index = bytecode.readU1(bci + 1);
Object constant = method.getConstant(index);
stack[stackPointer++] = constant;
bci += 2;
break;
case Opcodes.ILOAD:
int localIndex = bytecode.readU1(bci + 1);
stack[stackPointer++] = locals[localIndex];
bci += 2;
break;
case Opcodes.ISTORE:
localIndex = bytecode.readU1(bci + 1);
locals[localIndex] = stack[--stackPointer];
bci += 2;
break;
case Opcodes.IADD:
int value2 = (Integer) stack[--stackPointer];
int value1 = (Integer) stack[--stackPointer];
stack[stackPointer++] = value1 + value2;
bci += 1;
break;
case Opcodes.INVOKEVIRTUAL:
int methodRefIndex = bytecode.readU2(bci + 1);
EspressoMethod targetMethod = resolveMethod(methodRefIndex, method);
// Pop arguments from stack
Object[] methodArgs = new Object[targetMethod.getParameterCount()];
for (int i = targetMethod.getParameterCount() - 1; i >= 0; i--) {
methodArgs[i] = stack[--stackPointer];
}
// Pop receiver
StaticObject receiver = (StaticObject) stack[--stackPointer];
// Invoke method
Object result = executeMethod(receiver, targetMethod, methodArgs);
// Push result if not void
if (targetMethod.getReturnType() != Void.TYPE) {
stack[stackPointer++] = result;
}
bci += 3;
break;
case Opcodes.RETURN:
return null;
case Opcodes.IRETURN:
return stack[--stackPointer];
default:
throw new EspressoException("Unsupported opcode: " + opcode);
}
}
return null;
}
private EspressoMethod resolveMethod(int methodRefIndex, EspressoMethod currentMethod) {
// Resolve method reference from constant pool
MethodRef methodRef = (MethodRef) currentMethod.getConstant(methodRefIndex);
return methodRef.resolve(currentMethod.getDeclaringClass());
}
}
// Bytecode opcodes
class Opcodes {
public static final int NOP = 0;
public static final int ACONST_NULL = 1;
public static final int ICONST_0 = 3;
public static final int ICONST_1 = 4;
public static final int LDC = 18;
public static final int ILOAD = 21;
public static final int ISTORE = 54;
public static final int IADD = 96;
public static final int INVOKEVIRTUAL = 182;
public static final int RETURN = 177;
public static final int IRETURN = 172;
}
Truffle Framework Integration
Step 4: Truffle Language Implementation
package com.oracle.truffle.espresso;
import com.oracle.truffle.api.CallTarget;
import com.oracle.truffle.api.Truffle;
import com.oracle.truffle.api.TruffleLanguage;
import com.oracle.truffle.api.frame.FrameDescriptor;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.RootNode;
import com.oracle.truffle.espresso.runtime.EspressoContext;
import com.oracle.truffle.espresso.runtime.StaticObject;
@TruffleLanguage.Registration(
id = "java",
name = "Java",
version = "11",
characterMimeTypes = {"application/java"}
)
public final class EspressoLanguage extends TruffleLanguage<EspressoContext> {
@Override
protected EspressoContext createContext(Env env) {
return new EspressoContext(this, env);
}
@Override
protected CallTarget parse(ParsingRequest request) {
String sourceName = request.getSource().getName();
String className = sourceName.replace(".java", "").replace("/", ".");
// Load the requested class
EspressoContext context = getCurrentContext();
EspressoClass targetClass = context.getClassRegistry().loadClass(className);
// Find main method
EspressoMethod mainMethod = targetClass.findMethod("main", "([Ljava/lang/String;)V");
if (mainMethod == null) {
throw new EspressoException("No main method found in class: " + className);
}
// Create call target for the main method
RootNode rootNode = new EspressoRootNode(
this,
FrameDescriptor.newBuilder().build(),
mainMethod,
null // static method, no receiver
);
return Truffle.getRuntime().createCallTarget(rootNode);
}
@Override
protected Object getScope(EspressoContext context) {
return context.getGlobalScope();
}
// Espresso Root Node
private static class EspressoRootNode extends RootNode {
private final EspressoMethod method;
private final StaticObject receiver;
protected EspressoRootNode(EspressoLanguage language,
FrameDescriptor frameDescriptor,
EspressoMethod method,
StaticObject receiver) {
super(language, frameDescriptor);
this.method = method;
this.receiver = receiver;
}
@Override
public Object execute(VirtualFrame frame) {
// Get arguments from frame
Object[] arguments = frame.getArguments();
// Execute the method
return method.invoke(receiver, arguments);
}
}
}
Object Model and Memory Management
Step 5: Espresso Object Representation
package com.oracle.truffle.espresso.runtime;
public class StaticObject {
private final EspressoClass klass;
private final Object[] fields;
private final Object monitor;
private final int identityHashCode;
public StaticObject(EspressoClass klass) {
this.klass = klass;
this.fields = new Object[klass.getInstanceFieldCount()];
this.monitor = new Object();
this.identityHashCode = System.identityHashCode(this);
}
public EspressoClass getKlass() {
return klass;
}
public Object getField(Field field) {
int fieldIndex = field.getIndex();
if (fieldIndex < 0 || fieldIndex >= fields.length) {
throw new EspressoException("Invalid field index: " + fieldIndex);
}
return fields[fieldIndex];
}
public void setField(Field field, Object value) {
int fieldIndex = field.getIndex();
if (fieldIndex < 0 || fieldIndex >= fields.length) {
throw new EspressoException("Invalid field index: " + fieldIndex);
}
// Verify type compatibility
if (!isAssignable(field.getType(), value)) {
throw new EspressoException("Type mismatch for field: " + field.getName());
}
fields[fieldIndex] = value;
}
private boolean isAssignable(EspressoClass fieldType, Object value) {
if (value == null) {
return !fieldType.isPrimitive();
}
if (fieldType.isPrimitive()) {
return isPrimitiveWrapperCompatible(fieldType, value);
}
if (value instanceof StaticObject) {
StaticObject objValue = (StaticObject) value;
return fieldType.isAssignableFrom(objValue.getKlass());
}
return false;
}
private boolean isPrimitiveWrapperCompatible(EspressoClass primitiveType, Object value) {
// Handle primitive type compatibility
if (primitiveType.getName().equals("int") && value instanceof Integer) return true;
if (primitiveType.getName().equals("long") && value instanceof Long) return true;
if (primitiveType.getName().equals("double") && value instanceof Double) return true;
if (primitiveType.getName().equals("float") && value instanceof Float) return true;
if (primitiveType.getName().equals("boolean") && value instanceof Boolean) return true;
if (primitiveType.getName().equals("char") && value instanceof Character) return true;
if (primitiveType.getName().equals("byte") && value instanceof Byte) return true;
if (primitiveType.getName().equals("short") && value instanceof Short) return true;
return false;
}
public void monitorEnter() {
synchronized (monitor) {
// Monitor enter implementation
}
}
public void monitorExit() {
synchronized (monitor) {
// Monitor exit implementation
}
}
@Override
public int hashCode() {
return identityHashCode;
}
@Override
public boolean equals(Object obj) {
return this == obj;
}
// Array support
public static class Array extends StaticObject {
private final Object[] array;
private final int length;
public Array(EspressoClass arrayClass, int length) {
super(arrayClass);
this.length = length;
this.array = new Object[length];
}
public Object getElement(int index) {
checkIndex(index);
return array[index];
}
public void setElement(int index, Object value) {
checkIndex(index);
// Verify type compatibility
EspressoClass componentType = getKlass().getComponentType();
if (!isAssignable(componentType, value)) {
throw new EspressoException("Array type mismatch");
}
array[index] = value;
}
public int length() {
return length;
}
private void checkIndex(int index) {
if (index < 0 || index >= length) {
throw new ArrayIndexOutOfBoundsException(index);
}
}
}
}
Class Loading and Resolution
Step 6: Class Loading System
package com.oracle.truffle.espresso.classloader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
public class EspressoClassLoader {
private final Map<String, EspressoClass> loadedClasses;
private final ClassPath classPath;
private final EspressoClassLoader parent;
public EspressoClassLoader() {
this(null);
}
public EspressoClassLoader(EspressoClassLoader parent) {
this.loadedClasses = new HashMap<>();
this.classPath = new ClassPath();
this.parent = parent;
// Load fundamental classes
loadPrimitiveClasses();
loadArrayClass();
}
public EspressoClass loadClass(String className) {
// Check if already loaded
EspressoClass loaded = loadedClasses.get(className);
if (loaded != null) {
return loaded;
}
// Delegate to parent if exists
if (parent != null) {
loaded = parent.loadClass(className);
if (loaded != null) {
loadedClasses.put(className, loaded);
return loaded;
}
}
// Load from class path
byte[] classData = classPath.findClass(className);
if (classData == null) {
throw new EspressoException("Class not found: " + className);
}
// Parse class file
EspressoClass klass = defineClass(className, classData);
loadedClasses.put(className, klass);
return klass;
}
private EspressoClass defineClass(String className, byte[] classData) {
ClassFileParser parser = new ClassFileParser(classData);
ClassFile classFile = parser.parse();
// Verify class file
if (!classFile.getMagic() == 0xCAFEBABE) {
throw new EspressoException("Invalid class file format");
}
// Resolve superclass
EspressoClass superClass = null;
if (classFile.getSuperClass() != null) {
superClass = loadClass(classFile.getSuperClass());
}
// Resolve interfaces
EspressoClass[] interfaces = new EspressoClass[classFile.getInterfaces().length];
for (int i = 0; i < interfaces.length; i++) {
interfaces[i] = loadClass(classFile.getInterfaces()[i]);
}
// Create fields
Field[] fields = new Field[classFile.getFields().length];
for (int i = 0; i < fields.length; i++) {
FieldInfo fieldInfo = classFile.getFields()[i];
fields[i] = new Field(fieldInfo, this);
}
// Create methods
Method[] methods = new Method[classFile.getMethods().length];
for (int i = 0; i < methods.length; i++) {
MethodInfo methodInfo = classFile.getMethods()[i];
methods[i] = new Method(methodInfo, this);
}
return new EspressoClass(
className,
superClass,
interfaces,
fields,
methods,
classFile.getConstantPool(),
classFile.getAccessFlags(),
this
);
}
private void loadPrimitiveClasses() {
// Load primitive type classes
String[] primitives = {"void", "boolean", "char", "byte", "short", "int", "long", "float", "double"};
for (String primitive : primitives) {
EspressoClass primitiveClass = new PrimitiveClass(primitive);
loadedClasses.put(primitive, primitiveClass);
}
}
private void loadArrayClass() {
// Create array class
EspressoClass arrayClass = new ArrayClass("[Ljava/lang/Object;");
loadedClasses.put("[Ljava/lang/Object;", arrayClass);
}
}
class ClassPath {
private final Path[] paths;
public ClassPath() {
this.paths = new Path[]{
Paths.get("."),
Paths.get(System.getProperty("java.class.path"))
};
}
public byte[] findClass(String className) {
String classFile = className.replace('.', '/') + ".class";
for (Path path : paths) {
Path fullPath = path.resolve(classFile);
if (Files.exists(fullPath)) {
try {
return Files.readAllBytes(fullPath);
} catch (IOException e) {
// Continue to next path
}
}
}
return null;
}
}
Method Execution and Optimization
Step 7: Method Handling and Optimization
package com.oracle.truffle.espresso.runtime;
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.nodes.Node;
public class EspressoMethod {
private final String name;
private final String descriptor;
private final EspressoClass declaringClass;
private final int accessFlags;
private final byte[] bytecode;
private final int maxStack;
private final int maxLocals;
@CompilationFinal
private MethodNode methodNode;
public EspressoMethod(String name,
String descriptor,
EspressoClass declaringClass,
int accessFlags,
byte[] bytecode,
int maxStack,
int maxLocals) {
this.name = name;
this.descriptor = descriptor;
this.declaringClass = declaringClass;
this.accessFlags = accessFlags;
this.bytecode = bytecode;
this.maxStack = maxStack;
this.maxLocals = maxLocals;
}
public Object invoke(StaticObject receiver, Object[] arguments) {
if (methodNode == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
methodNode = insert(new MethodNode(this));
}
return methodNode.execute(receiver, arguments);
}
public boolean isStatic() {
return (accessFlags & java.lang.reflect.Modifier.STATIC) != 0;
}
public boolean isNative() {
return (accessFlags & java.lang.reflect.Modifier.NATIVE) != 0;
}
public int getParameterCount() {
// Parse descriptor to count parameters
return parseParameterCount(descriptor);
}
private int parseParameterCount(String descriptor) {
int count = 0;
int index = 1; // Skip opening '('
while (descriptor.charAt(index) != ')') {
char c = descriptor.charAt(index);
switch (c) {
case 'L':
// Object type
index = descriptor.indexOf(';', index) + 1;
count++;
break;
case '[':
// Array type
index++;
break;
default:
// Primitive type
index++;
count++;
break;
}
}
return count;
}
// Method execution node for Truffle
private static class MethodNode extends Node {
private final EspressoMethod method;
@CompilationFinal
private boolean interpreted = true;
public MethodNode(EspressoMethod method) {
this.method = method;
}
public Object execute(StaticObject receiver, Object[] arguments) {
if (interpreted) {
return executeInterpreted(receiver, arguments);
} else {
// For compiled methods
CompilerDirectives.transferToInterpreterAndInvalidate();
return executeInterpreted(receiver, arguments);
}
}
@CompilerDirectives.TruffleBoundary
private Object executeInterpreted(StaticObject receiver, Object[] arguments) {
// Use bytecode interpreter
BytecodeInterpreter interpreter =
method.declaringClass.getContext().getInterpreter();
return interpreter.executeMethod(receiver, method, arguments);
}
}
}
Practical Espresso Usage
Step 8: Running Java on Espresso
package com.example;
public class EspressoDemo {
// Example class to run on Espresso
public static class Calculator {
private int value;
public Calculator(int initialValue) {
this.value = initialValue;
}
public void add(int operand) {
value += operand;
}
public void multiply(int operand) {
value *= operand;
}
public int getValue() {
return value;
}
public static int staticMethod(int x, int y) {
return x * x + y * y;
}
}
// Main class to execute
public static class Main {
public static void main(String[] args) {
System.out.println("Running Java on Espresso VM!");
// Create objects and call methods
Calculator calc = new Calculator(10);
calc.add(5);
calc.multiply(2);
System.out.println("Calculator result: " + calc.getValue());
System.out.println("Static method result: " + Calculator.staticMethod(3, 4));
// Array operations
int[] numbers = {1, 2, 3, 4, 5};
int sum = 0;
for (int num : numbers) {
sum += num;
}
System.out.println("Array sum: " + sum);
// String operations
String message = "Hello, Espresso!";
System.out.println("Message: " + message);
System.out.println("Reversed: " + reverseString(message));
}
public static String reverseString(String input) {
char[] chars = input.toCharArray();
int left = 0, right = chars.length - 1;
while (left < right) {
char temp = chars[left];
chars[left] = chars[right];
chars[right] = temp;
left++;
right--;
}
return new String(chars);
}
}
// Espresso VM launcher
public static class EspressoLauncher {
public static void main(String[] args) {
// Create Espresso VM instance
EspressoVM vm = new EspressoVM();
// Run our demo class
String[] mainArgs = {};
vm.executeClass("com.example.EspressoDemo$Main", mainArgs);
}
}
}
Advanced Features and Extensions
Step 9: Native Method Integration
package com.oracle.truffle.espresso.native;
public class NativeMethodHandler {
private final Map<String, NativeFunction> nativeMethods;
public NativeMethodHandler() {
this.nativeMethods = new HashMap<>();
registerStandardNativeMethods();
}
private void registerStandardNativeMethods() {
// Register JNI native methods
registerMethod("java/lang/System.currentTimeMillis", "()J",
(receiver, args) -> System.currentTimeMillis());
registerMethod("java/lang/System.arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V",
this::arraycopy);
registerMethod("java/lang/Object.hashCode", "()I",
(receiver, args) -> receiver.hashCode());
registerMethod("java/lang/String.length", "()I",
(receiver, args) -> ((String) receiver).length());
}
private void arraycopy(StaticObject src, int srcPos,
StaticObject dest, int destPos, int length) {
if (!(src instanceof StaticObject.Array) ||
!(dest instanceof StaticObject.Array)) {
throw new EspressoException("ArrayCopy requires array objects");
}
StaticObject.Array srcArray = (StaticObject.Array) src;
StaticObject.Array destArray = (StaticObject.Array) dest;
for (int i = 0; i < length; i++) {
Object element = srcArray.getElement(srcPos + i);
destArray.setElement(destPos + i, element);
}
}
public void registerMethod(String className, String methodName,
NativeFunction function) {
String key = className + "." + methodName;
nativeMethods.put(key, function);
}
public Object invokeNativeMethod(String className, String methodName,
StaticObject receiver, Object[] args) {
String key = className + "." + methodName;
NativeFunction function = nativeMethods.get(key);
if (function == null) {
throw new EspressoException("Native method not found: " + key);
}
return function.invoke(receiver, args);
}
@FunctionalInterface
public interface NativeFunction {
Object invoke(StaticObject receiver, Object[] args);
}
}
Performance Monitoring and Debugging
Step 10: Debugging and Profiling Support
package com.oracle.truffle.espresso.debug;
public class EspressoDebugger {
private final EspressoContext context;
private final Set<Breakpoint> breakpoints;
private boolean suspended = false;
public EspressoDebugger(EspressoContext context) {
this.context = context;
this.breakpoints = new HashSet<>();
}
public void setBreakpoint(String className, int lineNumber) {
Breakpoint breakpoint = new Breakpoint(className, lineNumber);
breakpoints.add(breakpoint);
}
public void stepOver() {
// Implementation for step-over functionality
}
public void stepInto() {
// Implementation for step-into functionality
}
public void stepOut() {
// Implementation for step-out functionality
}
public void resume() {
suspended = false;
}
public StackTraceElement[] getStackTrace() {
// Get current execution stack
return new StackTraceElement[0]; // Implementation details
}
public Object evaluateExpression(String expression) {
// Simple expression evaluation
return null; // Implementation details
}
public static class Breakpoint {
private final String className;
private final int lineNumber;
private boolean enabled = true;
public Breakpoint(String className, int lineNumber) {
this.className = className;
this.lineNumber = lineNumber;
}
public boolean matches(String currentClass, int currentLine) {
return enabled &&
className.equals(currentClass) &&
lineNumber == currentLine;
}
}
}
// Performance monitoring
package com.oracle.truffle.espresso.monitoring;
public class EspressoProfiler {
private final Map<String, MethodStats> methodStats;
private long startTime;
public EspressoProfiler() {
this.methodStats = new HashMap<>();
this.startTime = System.nanoTime();
}
public void methodEnter(String methodName) {
MethodStats stats = methodStats.computeIfAbsent(methodName,
k -> new MethodStats());
stats.enter();
}
public void methodExit(String methodName, long duration) {
MethodStats stats = methodStats.get(methodName);
if (stats != null) {
stats.exit(duration);
}
}
public void printProfileReport() {
System.out.println("=== Espresso Profiling Report ===");
System.out.printf("%-40s %10s %10s %10s%n",
"Method", "Calls", "Total(ms)", "Avg(ms)");
methodStats.entrySet().stream()
.sorted((a, b) -> Long.compare(b.getValue().totalTime, a.getValue().totalTime))
.forEach(entry -> {
MethodStats stats = entry.getValue();
if (stats.callCount > 0) {
double totalMs = stats.totalTime / 1_000_000.0;
double avgMs = totalMs / stats.callCount;
System.out.printf("%-40s %10d %10.2f %10.4f%n",
entry.getKey(), stats.callCount, totalMs, avgMs);
}
});
}
private static class MethodStats {
private int callCount;
private long totalTime;
private long currentEntryTime;
public void enter() {
currentEntryTime = System.nanoTime();
callCount++;
}
public void exit(long duration) {
totalTime += duration;
}
}
}
Key Benefits and Use Cases
Benefits of Espresso:
- Meta-circular Implementation: Java VM written in Java
- GraalVM Integration: Seamless integration with Graal compiler
- Research Platform: Ideal for JVM research and experimentation
- Embeddable: Can run Java within Java applications
- Modern Features: Supports latest Java features
Use Cases:
- JVM Research: Experiment with new VM features
- Language Implementation: Base for implementing other languages
- Educational Tool: Learn JVM internals
- Embedded Scripting: Run Java code within Java applications
- Testing Framework: Test JVM implementations
Espresso represents a significant achievement in meta-circular implementation, demonstrating that complex systems like JVMs can be implemented in their own language while maintaining performance and compatibility.