Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/***** BEGIN LICENSE BLOCK *****
* Version: CPL 1.0/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Common Public
* License Version 1.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.eclipse.org/legal/cpl-v10.html
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* Copyright (C) 2006-2008 Charles O Nutter
* Copyright (C) 2008 Thomas E Enebo
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the CPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the CPL, the GPL or the LGPL.
***** END LICENSE BLOCK *****/
package org.jruby.compiler;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import org.jruby.Ruby;
import org.jruby.RubyModule;
import org.jruby.MetaClass;
import org.jruby.RubyEncoding;
import org.jruby.RubyInstanceConfig;
import org.jruby.ast.ArgsNode;
import org.jruby.ast.Node;
import org.jruby.ast.executable.Script;
import org.jruby.ast.util.SexpMaker;
import org.jruby.compiler.impl.StandardASMCompiler;
import org.jruby.runtime.builtin.IRubyObject;
import org.jruby.internal.runtime.methods.CallConfiguration;
import org.jruby.internal.runtime.methods.DefaultMethod;
import org.jruby.parser.StaticScope;
import org.jruby.runtime.ThreadContext;
import org.jruby.threading.DaemonThreadFactory;
import org.jruby.util.ClassCache;
import org.jruby.util.JavaNameMangler;
import org.jruby.util.cli.Options;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.util.TraceClassVisitor;
import org.jruby.util.log.Logger;
import org.jruby.util.log.LoggerFactory;
public class JITCompiler implements JITCompilerMBean {
private static final Logger LOG = LoggerFactory.getLogger("JITCompiler");
public static final boolean USE_CACHE = true;
public static final String RUBY_JIT_PREFIX = "rubyjit";
public static final String CLASS_METHOD_DELIMITER = "$$";
public static class JITCounts {
private final AtomicLong compiledCount = new AtomicLong(0);
private final AtomicLong successCount = new AtomicLong(0);
private final AtomicLong failCount = new AtomicLong(0);
private final AtomicLong abandonCount = new AtomicLong(0);
private final AtomicLong compileTime = new AtomicLong(0);
private final AtomicLong averageCompileTime = new AtomicLong(0);
private final AtomicLong codeSize = new AtomicLong(0);
private final AtomicLong averageCodeSize = new AtomicLong(0);
private final AtomicLong largestCodeSize = new AtomicLong(0);
}
private final JITCounts counts = new JITCounts();
private final ExecutorService executor = new ThreadPoolExecutor(
2, // always two threads
2,
0, // never stop
TimeUnit.SECONDS,
new LinkedBlockingQueue(),
new DaemonThreadFactory("JRubyJIT"));
public JITCompiler(Ruby ruby) {
ruby.getBeanManager().register(this);
}
public void tryJIT(DefaultMethod method, ThreadContext context, String className, String methodName) {
if (context.runtime.getInstanceConfig().getCompileMode().shouldJIT()) {
jitIsEnabled(method, context, className, methodName);
}
}
public void tearDown() {
if (executor != null) {
try {
executor.shutdown();
} catch (SecurityException se) {
// ignore, can't shut down executor
}
}
}
private void jitIsEnabled(DefaultMethod method, ThreadContext context, String className, String methodName) {
RubyInstanceConfig instanceConfig = context.runtime.getInstanceConfig();
if (method.incrementCallCount() >= instanceConfig.getJitThreshold()) {
jitThresholdReached(method, instanceConfig, context, className, methodName);
}
}
private void jitThresholdReached(final DefaultMethod method, final RubyInstanceConfig config, ThreadContext context, final String className, final String methodName) {
// Disable any other jit tasks from entering queue
method.setCallCount(-1);
final Ruby runtime = context.runtime;
Runnable jitTask = new Runnable() {
public void run() {
try {
// The cache is full. Abandon JIT for this method and bail out.
ClassCache classCache = config.getClassCache();
if (classCache.isFull()) {
counts.abandonCount.incrementAndGet();
return;
}
// Check if the method has been explicitly excluded
if (config.getExcludedMethods().size() > 0) {
String excludeModuleName = className;
if (method.getImplementationClass().isSingleton()) {
IRubyObject possibleRealClass = ((MetaClass) method.getImplementationClass()).getAttached();
if (possibleRealClass instanceof RubyModule) {
excludeModuleName = "Meta:" + ((RubyModule) possibleRealClass).getName();
}
}
if ((config.getExcludedMethods().contains(excludeModuleName)
|| config.getExcludedMethods().contains(excludeModuleName + "#" + methodName)
|| config.getExcludedMethods().contains(methodName))) {
method.setCallCount(-1);
log(method, methodName, "skipping method: " + excludeModuleName + "#" + methodName);
return;
}
}
String key = SexpMaker.create(methodName, method.getArgsNode(), method.getBodyNode());
JITClassGenerator generator = new JITClassGenerator(className, methodName, key, runtime, method, counts);
Class
