/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.ode.jacob.vpu;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ode.jacob.*;
import org.apache.ode.jacob.soup.*;
import org.apache.ode.utils.CollectionUtils;
import org.apache.ode.utils.ObjectPrinter;
import org.apache.ode.utils.msg.MessageBundle;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
/**
* The JACOB Virtual Processing Unit ("VPU").
*
* @author Maciej Szefler <a href="mailto:mbs@fivesight.com" />
*/
public final class JacobVPU {
private static final Log __log = LogFactory.getLog(JacobVPU.class);
/**
* Internationalization messages.
*/
private static final JacobMessages __msgs = MessageBundle.getMessages(JacobMessages.class);
/**
* Thread-local for associating a thread with a VPU. Needs to be stored in a stack to allow reentrance.
*/
static final ThreadLocal<Stack<JacobThread>> __activeJacobThread = new ThreadLocal<Stack<JacobThread>>();
private static final Method REDUCE_METHOD;
/**
* Resolve the {@link JacobRunnable#run} method statically
*/
static {
try {
REDUCE_METHOD = JacobRunnable.class.getMethod("run", CollectionUtils.EMPTY_CLASS_ARRAY);
} catch (Exception e) {
throw new Error("Cannot resolve 'run' method", e);
}
}
/**
* Persisted cross-VPU state (state of the channels)
*/
private ExecutionQueue _executionQueue;
private Map<Class, Object> _extensions = new HashMap<Class, Object>();
/**
* Classloader used for loading object continuations.
*/
private ClassLoader _classLoader = getClass().getClassLoader();
private int _cycle;
private Statistics _statistics = new Statistics();
/**
* The fault "register" of the VPU .
*/
private RuntimeException _fault;
/**
* Default constructor.
*/
public JacobVPU() {
}
/**
* Re-hydration constructor.
*
* @param executionQueue previously saved execution context
*/
public JacobVPU(ExecutionQueue executionQueue) {
setContext(executionQueue);
}
/**
* Instantiation constructor; used to initialize context with the concretion
* of a process abstraction.
*
* @param context virgin context object
* @param concretion the process
*/
public JacobVPU(ExecutionQueue context, JacobRunnable concretion) {
setContext(context);
inject(concretion);
}
/**
* Execute one VPU cycle.
*
* @return <code>true</code> if the run queue is not empty after this cycle, <code>false</code> otherwise.
*/
public boolean execute() {
if (__log.isTraceEnabled()) {
__log.trace(ObjectPrinter.stringifyMethodEnter("execute", CollectionUtils.EMPTY_OBJECT_ARRAY));
}
if (_executionQueue == null) {
throw new IllegalStateException("No state object for VPU!");
}
if (_fault != null) {
throw _fault;
}
if (!_executionQueue.hasReactions()) {
return false;
}
_cycle = _executionQueue.cycle();
Continuation rqe = _executionQueue.dequeueReaction();
JacobThreadImpl jt = new JacobThreadImpl(rqe);
long ctime = System.currentTimeMillis();
try {
jt.run();
} catch (RuntimeException re) {
_fault = re;
throw re;
}
long rtime = System.currentTimeMillis() - ctime;
++_statistics.numCycles;
_statistics.totalRunTimeMs += rtime;
_statistics.incRunTime(jt._targetStr, rtime);
return true;
}
public void flush() {
if (__log.isTraceEnabled()) {
__log.trace(ObjectPrinter.stringifyMethodEnter("flush", CollectionUtils.EMPTY_OBJECT_ARRAY));
}
_executionQueue.flush();
}
/**
* Set the state of of the VPU; this is analagous to loading a CPU with a
* thread's context (re-hydration).
*
* @param executionQueue
* process executionQueue (state)
*/
public void setContext(ExecutionQueue executionQueue) {
if (__log.isTraceEnabled()) {
__log.trace(ObjectPrinter.stringifyMethodEnter("setContext",
new Object[] { "executionQueue", executionQueue }));
}
_executionQueue = executionQueue;
_executionQueue.setClassLoader(_classLoader);
}
public void registerExtension(Class extensionClass, Object obj) {
if (__log.isTraceEnabled()) {
__log.trace(ObjectPrinter
.stringifyMethodEnter("registerExtension", new Object[] {
"extensionClass", extensionClass, "obj", obj }));
}
_extensions.put(extensionClass, obj);
}
/**
* Add an item to the run queue.
*/
public void addReaction(JacobObject jo, Method method, Object[] args, String desc) {
if (__log.isTraceEnabled()) {
__log.trace(ObjectPrinter.stringifyMethodEnter("addReaction",
new Object[] { "jo", jo, "method", method, "args", args, "desc", desc }));
}
Continuation continuation = new Continuation(jo, method, args);
continuation.setDescription(desc);
_executionQueue.enqueueReaction(continuation);
++_statistics.runQueueEntries;
}
/**
* Get the active Jacob thread, i.e. the one associated with the current Java thread.
*/
public static JacobThread activeJacobThread() {
return __activeJacobThread.get().peek();
}
/**
* Inject a concretion into the process context. This amounts to chaning the
* process context from <code>P</code> to <code>P|Q</code> where
* <code>P</code> is the previous process context and <code>Q</code> is
* the injected process. This method is equivalent to the parallel operator,
* but is intended to be used from outside of an active {@link JacobThread}.
*/
public void inject(JacobRunnable concretion) {
if (__log.isDebugEnabled()) {
__log.debug("injecting " + concretion);
}
addReaction(concretion, REDUCE_METHOD, CollectionUtils.EMPTY_OBJECT_ARRAY,
(__log.isInfoEnabled() ? concretion.toString() : null));
}
static String stringifyMethods(Class kind) {
StringBuffer buf = new StringBuffer();
Method[] methods = kind.getMethods();
boolean found = false;
for (Method method : methods) {
if (method.getDeclaringClass() == Object.class) {
continue;
}
if (found) {
buf.append(" & ");
}
buf.append(method.getName()).append('(');
Class[] argTypes = method.getParameterTypes();
for (int j = 0; j < argTypes.length; ++j) {
if (j > 0) {
buf.append(", ");
}
buf.append(argTypes[j].getName());
}
buf.append(") {...}");
found = true;
}
return buf.toString();
}
static String stringify(Object[] list) {
if (list == null) {
return "";
}
StringBuffer buf = new StringBuffer();
for (int i = 0; i < list.length; ++i) {
if (i > 0) {
buf.append(',');
}
buf.append(list[i]);
}
return buf.toString();
}
public void setClassLoader(ClassLoader classLoader) {
_classLoader = classLoader;
if (_executionQueue != null) {
_executionQueue.setClassLoader(classLoader);
}
}
/**
* Dump the state of the VPU for debugging purposes.
*/
public void dumpState() {
_statistics.printToStream(System.err);
_executionQueue.dumpState(System.err);
}
public boolean isComplete() {
return _executionQueue.isComplete();
}
private class JacobThreadImpl implements Runnable, JacobThread {
private final JacobObject _methodBody;
private final Object[] _args;
private final Method _method;
/** Text string identifying the left side of the reduction (for debug). */
private String _source;
/** Text string identifying the target class and method (for debug) . */
private String _targetStr = "Unknown";
JacobThreadImpl(Continuation rqe) {
assert rqe != null;
_methodBody = rqe.getClosure();
_args = rqe.getArgs();
_source = rqe.getDescription();
_method = rqe.getMethod();
if (__log.isDebugEnabled()) {
StringBuffer buf = new StringBuffer(_methodBody.getClass().getName());
buf.append('.');
buf.append(rqe.getMethod());
_targetStr = buf.toString();
}
}
public void instance(JacobRunnable template) {
String desc = null;
if (__log.isTraceEnabled()) {
__log.trace(_cycle + ": " + template);
desc = template.toString();
}
_statistics.numReductionsStruct++;
addReaction(template, REDUCE_METHOD, CollectionUtils.EMPTY_OBJECT_ARRAY, desc);
}
public Channel message(Channel channel, Method method, Object[] args) {
if (__log.isTraceEnabled()) {
__log.trace(_cycle + ": " + channel + " ! "
+ method.getName() + "(" + stringify(args) + ")");
}
_statistics.messagesSent++;
SynchChannel replyChannel = null;
// Check for synchronous methods; create a synchronization channel
if (method.getReturnType() != void.class) {
if (method.getReturnType() != SynchChannel.class) {
throw new IllegalStateException(
"ChannelListener method can only return SynchChannel: " + method);
}
replyChannel = (SynchChannel) newChannel(SynchChannel.class, "", "Reply Channel");
Object[] newArgs = new Object[args.length + 1];
System.arraycopy(args, 0, newArgs, 0, args.length);
newArgs[args.length] = replyChannel;
args = newArgs;
}
CommChannel chnl = (CommChannel) ChannelFactory.getBackend(channel);
CommGroup grp = new CommGroup(false);
CommSend send = new CommSend(chnl, method, args);
grp.add(send);
_executionQueue.add(grp);
return replyChannel;
}
public Channel newChannel(Class channelType, String creator, String description) {
CommChannel chnl = new CommChannel(channelType);
chnl.setDescription(description);
_executionQueue.add(chnl);
Channel ret = ChannelFactory.createChannel(chnl, channelType);
if (__log.isTraceEnabled())
__log.trace(_cycle + ": new " + ret);
_statistics.channelsCreated++;
return ret;
}
public String exportChannel(Channel channel) {
if (__log.isTraceEnabled()) {
__log.trace(_cycle + ": export<" + channel + ">");
}
CommChannel chnl = (CommChannel) ChannelFactory.getBackend(channel);
return _executionQueue.createExport(chnl);
}
public Channel importChannel(String channelId, Class channelType) {
CommChannel cframe = _executionQueue.consumeExport(channelId);
return ChannelFactory.createChannel(cframe, channelType);
}
public void object(boolean replicate, ChannelListener[] ml) {
if (__log.isTraceEnabled()) {
StringBuffer msg = new StringBuffer();
msg.append(_cycle);
msg.append(": ");
for (int i = 0; i < ml.length; ++i) {
if (i != 0) msg.append(" + ");
msg.append(ml[i].getChannel());
msg.append(" ? ");
msg.append(ml.toString());
}
__log.debug(msg.toString());
}
_statistics.numContinuations++;
CommGroup grp = new CommGroup(replicate);
for (int i = 0; i < ml.length; ++i) {
CommChannel chnl = (CommChannel) ChannelFactory
.getBackend(ml[i].getChannel());
// TODO see below..
// oframe.setDebugInfo(fillDebugInfo());
CommRecv recv = new CommRecv(chnl, ml[i]);
grp.add(recv);
}
_executionQueue.add(grp);
}
public void object(boolean replicate, ChannelListener methodList)
throws IllegalArgumentException {
object(replicate, new ChannelListener[] { methodList });
}
/* UNUSED
private DebugInfo fillDebugInfo() {
// Some of the debug information is a bit lengthy, so lets not put
// it in all the time... eh.
DebugInfo frame = new DebugInfo();
frame.setCreator(_source);
Exception ex = new Exception();
StackTraceElement[] st = ex.getStackTrace();
if (st.length > 2) {
StackTraceElement[] stcut = new StackTraceElement[st.length - 2];
System.arraycopy(st, 2, stcut, 0, stcut.length);
frame.setLocation(stcut);
}
return frame;
}
*/
public Object getExtension(Class extensionClass) {
return _extensions.get(extensionClass);
}
public void run() {
assert _methodBody != null;
assert _method != null;
assert _method.getDeclaringClass().isAssignableFrom(_methodBody.getClass());
if (__log.isTraceEnabled()) {
__log.trace(_cycle + ": " + _source);
}
Object[] args;
SynchChannel synchChannel;
if (_method.getReturnType() != void.class) {
args = new Object[_args.length - 1];
System.arraycopy(_args, 0, args, 0, args.length);
synchChannel = (SynchChannel) _args[args.length];
} else {
args = _args;
synchChannel = null;
}
stackThread();
long ctime = System.currentTimeMillis();
try {
_method.invoke(_methodBody, args);
if (synchChannel != null) {
synchChannel.ret();
}
} catch (IllegalAccessException iae) {
String msg = __msgs.msgMethodNotAccessible(_method.getName(),
_method.getDeclaringClass().getName());
__log.error(msg, iae);
throw new RuntimeException(msg, iae);
} catch (InvocationTargetException e) {
String msg = __msgs.msgClientMethodException(_method.getName(),
_methodBody.getClass().getName());
__log.error(msg, e.getTargetException());
throw new RuntimeException(e.getTargetException());
} finally {
ctime = System.currentTimeMillis() - ctime;
_statistics.totalClientTimeMs += ctime;
unstackThread();
}
}
public String toString() {
return "PT[ " + _methodBody + " ]";
}
private void stackThread() {
Stack<JacobThread> currStack = __activeJacobThread.get();
if (currStack == null) {
currStack = new Stack<JacobThread>();
__activeJacobThread.set(currStack);
}
currStack.push(this);
}
private JacobThread unstackThread() {
Stack<JacobThread> currStack = __activeJacobThread.get();
assert currStack != null;
return currStack.pop();
}
}
}