jit.java

kaffe Java 解释器语言,源码,Java的子集系统,开放源代码

/*
 * JIT.java
 * Interface to KVM JIT compiler.
 *
 * Copyright (c) 1998, 1999
 *      Transvirtual Technologies, Inc.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file.
 *
 * @author Godmar Back <[e-mail]>
 */
package kaffe.management;

/**
 * This class allow direct access to the KVM's translator
 * It allows to dump a description of all currently active methods
 * to a print stream, and it allows the restoration of that state
 * from a low-priority thread concurrently with a running program.
 * 
 * In certain application scenarios, this can be used to reduce the
 * perception of the startup latency introduced by loading and translating
 * classes and methods on demand.
 */

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.PrintStream;

public class JIT implements Runnable {
    /**
     * load a method consisting of class, method, signature.
     */
    public static native void translateMethod(String clazz, 
					String method, 
					String signature,
					ClassLoader loader);

    /**
     * load a method consisting of class, method, signature.
     */
    public static void translateMethod(String clazz, 
					String method, 
					String signature) 
    {
	translateMethod(clazz, method, signature, null);
    }

    /**
     * Do a full flush of the D cache to ensure all jitted code is out of
     * the cache.  Architecture-dependent.
     */
    public static native void flushCache();

    /**
     * load and translate from file using system classloader
     */
    public static void startPreloading(String fname) throws IOException 
    {
	startPreloading(fname, false);
    }

    /**
     * start loading classes through system loader
     */
    public static void startPreloading(String fname, boolean verbose) 
	throws IOException 
    {
	startPreloading(new FileInputStream(fname), null, verbose);
    }

    /**
     * load and translate from stream using given classloader and be verbose
     * or not.
     */
    public static void startPreloading(InputStream is, ClassLoader loader, boolean verbose) 
	throws IOException 
    {
	Thread t = new Thread(new JIT(is, loader, verbose));
	t.setPriority(Thread.MIN_PRIORITY);
	t.start();
    }

    public void run() {
	Thread.currentThread().setName("JIT-Translator");
	try {
	    String []l = new String[3];

	    for (;;) {
		for (int i = 0; i < l.length; i++) {
		    l[i] = reader.readLine();
		    if (l[i] == null) {
			throw new Exception("reached end of file");
		    }
		}
		if (verbose) {
		    System.err.println("translating " 
			+ l[0] + "." + l[1] + l[2]);
		}

		/* ignore linkage errors and exceptions */
		try {
		    translateMethod(l[0], l[1], l[2], loader);
		} catch (LinkageError le) {
		    if (verbose) {
			System.err.println("JIT-Translator: " + le);
		    }
		} catch (Exception e) {
		    if (verbose) {
			System.err.println("JIT-Translator: " + e);
		    }
		}
		Thread.yield();
	    }
	} catch (Exception _) {
	    if (verbose) {
		System.err.println("JIT-Translator: " + _);
	    }
	}

	flushCache();
	if (verbose) {
	    System.err.println("JIT-Translator done.");
	}
    }

    private JIT(InputStream is, ClassLoader loader, boolean verbose) throws IOException {
        this.verbose = verbose;
        this.loader = loader;
        this.reader = new LineNumberReader(new InputStreamReader(is));
    }

    private LineNumberReader    reader;
    private boolean             verbose;
    private ClassLoader         loader;

    public static void main(String av[]) throws IOException {
        PrintStream p = new PrintStream(new BufferedOutputStream(new FileOutputStream(av[0])));
        System.exit(0);
    }

    // load native library if not already loaded
    static {
        System.loadLibrary("management");
    }
}