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: EPL 1.0/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Eclipse 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/epl-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 EPL, 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 EPL, 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.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.IterNode;
import org.jruby.ast.LambdaNode;
import org.jruby.ast.MultipleAsgnNode;
import org.jruby.ast.Node;
import org.jruby.ast.NodeType;
import org.jruby.ast.executable.AbstractScript;
import org.jruby.ast.executable.Script;
import org.jruby.ast.util.SexpMaker;
import org.jruby.compiler.impl.ChildScopedBodyCompiler;
import org.jruby.compiler.impl.ChildScopedBodyCompiler19;
import org.jruby.compiler.impl.SkinnyMethodAdapter;
import org.jruby.compiler.impl.StandardASMCompiler;
import static org.jruby.compiler.impl.StandardASMCompiler.ARGS_INDEX;
import static org.jruby.compiler.impl.StandardASMCompiler.SELF_INDEX;
import static org.jruby.compiler.impl.StandardASMCompiler.THIS;
import static org.jruby.compiler.impl.StandardASMCompiler.THREADCONTEXT_INDEX;
import static org.jruby.compiler.impl.StandardASMCompiler.getMethodSignature;
import static org.jruby.compiler.impl.StandardASMCompiler.getStaticMethodSignature;
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.Arity;
import org.jruby.runtime.Binding;
import org.jruby.runtime.Block;
import org.jruby.runtime.BlockBody;
import static org.jruby.runtime.BlockBody.getArgumentTypeWackyHack;
import org.jruby.runtime.CompiledBlock;
import org.jruby.runtime.CompiledBlock19;
import org.jruby.runtime.CompiledBlockCallback;
import org.jruby.runtime.CompiledBlockCallback19;
import org.jruby.runtime.Helpers;
import org.jruby.runtime.ThreadContext;
import org.jruby.threading.DaemonThreadFactory;
import org.jruby.util.ClassCache;
import org.jruby.util.JRubyClassLoader;
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;
import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
public class JITCompiler implements JITCompilerMBean {
private static final Logger LOG = LoggerFactory.getLogger("JITCompiler");
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;
private final Ruby runtime;
private final RubyInstanceConfig config;
public JITCompiler(Ruby runtime) {
this.runtime = runtime;
this.config = runtime.getInstanceConfig();
this.executor = new ThreadPoolExecutor(
0, // don't start threads until needed
2, // two max
60, // stop then if no jitting for 60 seconds
TimeUnit.SECONDS,
new LinkedBlockingQueue(),
new DaemonThreadFactory("Ruby-" + runtime.getRuntimeNumber() + "-JIT", Thread.MIN_PRIORITY));
}
public long getSuccessCount() {
return counts.successCount.get();
}
public long getCompileCount() {
return counts.compiledCount.get();
}
public long getFailCount() {
return counts.failCount.get();
}
public long getCompileTime() {
return counts.compileTime.get() / 1000;
}
public long getAbandonCount() {
return counts.abandonCount.get();
}
public long getCodeSize() {
return counts.codeSize.get();
}
public long getAverageCodeSize() {
return counts.averageCodeSize.get();
}
public long getAverageCompileTime() {
return counts.averageCompileTime.get() / 1000;
}
public long getLargestCodeSize() {
return counts.largestCodeSize.get();
}
public void tryJIT(DefaultMethod method, ThreadContext context, String className, String methodName) {
if (!config.getCompileMode().shouldJIT()) return;
if (method.incrementCallCount() < config.getJitThreshold()) return;
jitThresholdReached(method, config, context, className, methodName);
}
public void tearDown() {
if (executor != null) {
try {
executor.shutdown();
} catch (SecurityException se) {
// ignore, can't shut down executor
}
}
}
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 JITTask(className, method, methodName);
// if background JIT is enabled and threshold is > 0 and we have an executor...
if (config.getJitBackground() &&
config.getJitThreshold() > 0 &&
executor != null) {
// JIT in background
try {
executor.submit(jitTask);
} catch (RejectedExecutionException ree) {
// failed to submit, just run it directly
jitTask.run();
}
} else {
// just run directly
jitTask.run();
}
}
private class JITTask implements Runnable {
private final String className;
private final DefaultMethod method;
private final String methodName;
public JITTask(String className, DefaultMethod method, String methodName) {
this.className = className;
this.method = method;
this.methodName = methodName;
}
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.sha1(methodName, method.getArgsNode(), method.getBodyNode());
JITClassGenerator generator = new JITClassGenerator(className, methodName, key, runtime, method, counts);
Class
