Java tutorial
/* * 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.Channel; import org.apache.ode.jacob.ChannelListener; import org.apache.ode.jacob.IndexedObject; import org.apache.ode.jacob.JacobObject; import org.apache.ode.jacob.soup.Comm; import org.apache.ode.jacob.soup.CommChannel; import org.apache.ode.jacob.soup.CommGroup; import org.apache.ode.jacob.soup.CommRecv; import org.apache.ode.jacob.soup.CommSend; import org.apache.ode.jacob.soup.Continuation; import org.apache.ode.jacob.soup.ExecutionQueue; import org.apache.ode.jacob.soup.ExecutionQueueObject; import org.apache.ode.jacob.soup.ReplacementMap; import org.apache.ode.utils.CollectionUtils; import org.apache.ode.utils.ObjectPrinter; import java.io.Externalizable; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectOutput; import java.io.ObjectOutputStream; import java.io.ObjectStreamClass; import java.io.OutputStream; import java.io.PrintStream; import java.io.Serializable; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.zip.GZIPInputStream; import java.util.zip.GZIPOutputStream; /** * A fast, in-memory {@link org.apache.ode.jacob.soup.ExecutionQueue} implementation. */ public class ExecutionQueueImpl implements ExecutionQueue { /** Class-level logger. */ private static final Log __log = LogFactory.getLog(ExecutionQueueImpl.class); private ClassLoader _classLoader; public static ConcurrentHashMap<String, ObjectStreamClass> _classDescriptors = new ConcurrentHashMap<String, ObjectStreamClass>(); /** * Cached set of enqueued {@link Continuation} objects (i.e. those read using * {@link #enqueueReaction(org.apache.ode.jacob.soup.Continuation)}). * These reactions are "cached"--that is it is not sent directly to the DAO * layer--to minimize unnecessary serialization/deserialization of closures. * This is a pretty useful optimization, as most {@link Continuation}s are * enqueued, and then immediately dequeued in the next cycle. By caching * {@link Continuation}s, we eliminate practically all serialization of * these objects, the only exception being cases where the system decides to * stop processing a particular soup despite the soup being able to make * forward progress; this scenario would occur if a maximum processign * time-per-instance policy were in effect. */ private Set<Continuation> _reactions = new HashSet<Continuation>(); private Map<Integer, ChannelFrame> _channels = new HashMap<Integer, ChannelFrame>(); /** * The "expected" cycle counter, use to detect database serialization * issues. */ private int _currentCycle; private int _objIdCounter; private ExecutionQueueStatistics _statistics = new ExecutionQueueStatistics(); private ReplacementMap _replacementMap; private Serializable _gdata; private Map<Object, LinkedList<IndexedObject>> _index = new HashMap<Object, LinkedList<IndexedObject>>(); public ExecutionQueueImpl(ClassLoader classLoader) { _classLoader = classLoader; } public void setClassLoader(ClassLoader classLoader) { _classLoader = classLoader; } public void setReplacementMap(ReplacementMap replacementMap) { _replacementMap = replacementMap; } public Map<Object, LinkedList<IndexedObject>> getIndex() { return _index; } public void add(CommChannel channel) { if (__log.isTraceEnabled()) __log.trace(ObjectPrinter.stringifyMethodEnter("add", new Object[] { "channel", channel })); verifyNew(channel); ChannelFrame cframe = new ChannelFrame(channel.getType(), ++_objIdCounter, channel.getType().getName(), channel.getDescription()); _channels.put(cframe.getId(), cframe); assignId(channel, cframe.getId()); } public void enqueueReaction(Continuation continuation) { if (__log.isTraceEnabled()) __log.trace(ObjectPrinter.stringifyMethodEnter("enqueueReaction", new Object[] { "continuation", continuation })); verifyNew(continuation); _reactions.add(continuation); } public Continuation dequeueReaction() { if (__log.isTraceEnabled()) { __log.trace(ObjectPrinter.stringifyMethodEnter("dequeueReaction", CollectionUtils.EMPTY_OBJECT_ARRAY)); } Continuation continuation = null; if (!_reactions.isEmpty()) { Iterator it = _reactions.iterator(); continuation = (Continuation) it.next(); it.remove(); } return continuation; } public void add(CommGroup group) { if (__log.isTraceEnabled()) __log.trace(ObjectPrinter.stringifyMethodEnter("add", new Object[] { "group", group })); verifyNew(group); CommGroupFrame commGroupFrame = new CommGroupFrame(group.isReplicated()); for (Iterator i = group.getElements(); i.hasNext();) { Comm comm = (Comm) i.next(); ChannelFrame chnlFrame = findChannelFrame(comm.getChannel().getId()); if (comm instanceof CommSend) { if (chnlFrame.replicatedSend) { // TODO: JACOB "bad-process" ex throw new IllegalStateException( "Send attempted on channel containing replicated send! Channel= " + comm.getChannel()); } if (group.isReplicated()) chnlFrame.replicatedSend = true; CommSend commSend = (CommSend) comm; MessageFrame mframe = new MessageFrame(commGroupFrame, chnlFrame, commSend.getMethod().getName(), commSend.getArgs()); commGroupFrame.commFrames.add(mframe); chnlFrame.msgFrames.add(mframe); } else if (comm instanceof CommRecv) { if (chnlFrame.replicatedRecv) { // TODO: JACOB "bad-process" ex throw new IllegalStateException( "Receive attempted on channel containing replicated receive! Channel= " + comm.getChannel()); } if (group.isReplicated()) chnlFrame.replicatedRecv = true; CommRecv commRecv = (CommRecv) comm; ObjectFrame oframe = new ObjectFrame(commGroupFrame, chnlFrame, commRecv.getContinuation()); commGroupFrame.commFrames.add(oframe); chnlFrame.objFrames.add(oframe); } } // Match communications. for (Iterator i = group.getElements(); i.hasNext();) { Comm comm = (Comm) i.next(); matchCommunications(comm.getChannel()); } } private ChannelFrame findChannelFrame(Object id) { ChannelFrame chnlFrame = _channels.get(id); if (chnlFrame == null) { throw new IllegalArgumentException("No such channel; id=" + id); } return chnlFrame; } public int cycle() { if (__log.isTraceEnabled()) { __log.trace(ObjectPrinter.stringifyMethodEnter("cycle", CollectionUtils.EMPTY_OBJECT_ARRAY)); } return ++_currentCycle; } public String createExport(CommChannel channel) { if (__log.isTraceEnabled()) __log.trace(ObjectPrinter.stringifyMethodEnter("createExport", new Object[] { "channel", channel })); ChannelFrame cframe = findChannelFrame(channel.getId()); cframe.refCount++; return channel.getId().toString(); } public CommChannel consumeExport(String exportId) { if (__log.isTraceEnabled()) { __log.trace(ObjectPrinter.stringifyMethodEnter("consumeExport", new Object[] { "exportId", exportId })); } Integer id = Integer.valueOf(exportId); ChannelFrame cframe = findChannelFrame(id); cframe.refCount--; CommChannel commChannel = new CommChannel(cframe.type); commChannel.setId(id); commChannel.setDescription("EXPORTED CHANNEL"); return commChannel; } public boolean hasReactions() { return !_reactions.isEmpty(); } public void flush() { if (__log.isTraceEnabled()) { __log.trace(ObjectPrinter.stringifyMethodEnter("flush", CollectionUtils.EMPTY_OBJECT_ARRAY)); } } public void read(InputStream iis) throws IOException, ClassNotFoundException { _channels.clear(); _reactions.clear(); _index.clear(); ExecutionQueueInputStream sis = new ExecutionQueueInputStream(iis); _objIdCounter = sis.readInt(); _currentCycle = sis.readInt(); int reactions = sis.readInt(); for (int i = 0; i < reactions; ++i) { JacobObject closure = (JacobObject) sis.readObject(); String methodName = sis.readUTF(); Method method = closure.getMethod(methodName); int numArgs = sis.readInt(); Object[] args = new Object[numArgs]; for (int j = 0; j < numArgs; ++j) { args[j] = sis.readObject(); } _reactions.add(new Continuation(closure, method, args)); } int numChannels = sis.readInt(); for (int i = 0; i < numChannels; ++i) { int objFrames = sis.readInt(); for (int j = 0; j < objFrames; ++j) { sis.readObject(); } int msgFrames = sis.readInt(); for (int j = 0; j < msgFrames; ++j) { sis.readObject(); } } numChannels = sis.readInt(); for (int i = 0; i < numChannels; ++i) { ChannelFrame cframe = (ChannelFrame) sis.readObject(); _channels.put(cframe.getId(), cframe); } _gdata = (Serializable) sis.readObject(); sis.close(); } private void index(IndexedObject object) { LinkedList<IndexedObject> vals = _index.get(object.getKey()); if (vals == null) { vals = new LinkedList<IndexedObject>(); _index.put(object.getKey(), vals); } vals.add(object); } public void write(OutputStream oos) throws IOException { flush(); ExecutionQueueOutputStream sos = new ExecutionQueueOutputStream(oos); // XQXMLOutputStream sos = createObjectOutputStream(new OutputStreamWriter(oos)); sos.writeInt(_objIdCounter); sos.writeInt(_currentCycle); // Write out the reactions. sos.writeInt(_reactions.size()); for (Continuation c : _reactions) { sos.writeObject(c.getClosure()); sos.writeUTF(c.getMethod().getName()); sos.writeInt(c.getArgs() == null ? 0 : c.getArgs().length); for (int j = 0; c.getArgs() != null && j < c.getArgs().length; ++j) sos.writeObject(c.getArgs()[j]); } sos.writeInt(_channels.values().size()); for (Iterator i = _channels.values().iterator(); i.hasNext();) { ChannelFrame cframe = (ChannelFrame) i.next(); sos.writeInt(cframe.objFrames.size()); for (Iterator j = cframe.objFrames.iterator(); j.hasNext();) { sos.writeObject(j.next()); } sos.writeInt(cframe.msgFrames.size()); for (Iterator j = cframe.msgFrames.iterator(); j.hasNext();) { sos.writeObject(j.next()); } } Set referencedChannels = sos.getSerializedChannels(); for (Iterator i = _channels.values().iterator(); i.hasNext();) { ChannelFrame cframe = (ChannelFrame) i.next(); if (referencedChannels.contains(Integer.valueOf(cframe.id)) || cframe.refCount > 0) { // skip } else { if (__log.isDebugEnabled()) __log.debug("GC Channel: " + cframe); i.remove(); } } sos.writeInt(_channels.values().size()); for (Iterator i = _channels.values().iterator(); i.hasNext();) { ChannelFrame cframe = (ChannelFrame) i.next(); if (__log.isDebugEnabled()) { __log.debug("Writing Channel: " + cframe); } sos.writeObject(cframe); } // Write the global data. sos.writeObject(_gdata); sos.close(); } public boolean isComplete() { // If we have more reactions we're not done. if (!_reactions.isEmpty()) { return false; } // If we have no reactions, but there are some channels that have // external references, we are not done. for (Iterator<ChannelFrame> i = _channels.values().iterator(); i.hasNext();) { if (i.next().refCount > 0) { return false; } } return true; } public void dumpState(PrintStream ps) { ps.print(this.toString()); ps.println(" state dump:"); ps.println("-- GENERAL INFO"); ps.println(" Current Cycle : " + _currentCycle); ps.println(" Num. Reactions : " + _reactions.size()); _statistics.printStatistics(ps); if (!_reactions.isEmpty()) { ps.println("-- REACTIONS"); int cnt = 0; for (Iterator i = _reactions.iterator(); i.hasNext();) { Continuation continuation = (Continuation) i.next(); ps.println(" #" + (++cnt) + ": " + continuation.toString()); } } } private void matchCommunications(CommChannel channel) { if (__log.isTraceEnabled()) { __log.trace( ObjectPrinter.stringifyMethodEnter("matchCommunications", new Object[] { "channel", channel })); } ChannelFrame cframe = _channels.get(channel.getId()); while (cframe != null && !cframe.msgFrames.isEmpty() && !cframe.objFrames.isEmpty()) { MessageFrame mframe = cframe.msgFrames.iterator().next(); ObjectFrame oframe = cframe.objFrames.iterator().next(); Continuation continuation = new Continuation(oframe._continuation, oframe._continuation.getMethod(mframe.method), mframe.args); if (__log.isInfoEnabled()) { continuation.setDescription(channel + " ? {...} | " + channel + " ! " + mframe.method + "(...)"); } enqueueReaction(continuation); if (!mframe.commGroupFrame.replicated) { removeCommGroup(mframe.commGroupFrame); } if (!oframe.commGroupFrame.replicated) { removeCommGroup(oframe.commGroupFrame); } } // Do some cleanup, if the channel is empty we can remove it from memory. // if (cframe != null && cframe.msgFrames.isEmpty() && // cframe.objFrames.isEmpty() && cframe.refCount ==0) // _channels.values().remove(cframe); } /** * Verify that a {@link ExecutionQueueObject} is new, that is it has not * already been added to the soup. * * @param so object to check. * @throws IllegalArgumentException in case the object is not new */ private void verifyNew(ExecutionQueueObject so) throws IllegalArgumentException { if (so.getId() != null) throw new IllegalArgumentException("The object " + so + " is not new!"); } private void assignId(ExecutionQueueObject so, Object id) { so.setId(id); } private void removeCommGroup(CommGroupFrame groupFrame) { // Add all channels reference in the group to the GC candidate set. for (Iterator i = groupFrame.commFrames.iterator(); i.hasNext();) { CommFrame frame = (CommFrame) i.next(); if (frame instanceof ObjectFrame) { assert frame.channelFrame.objFrames.contains(frame); frame.channelFrame.objFrames.remove(frame); } else { assert frame instanceof MessageFrame; assert frame.channelFrame.msgFrames.contains(frame); frame.channelFrame.msgFrames.remove(frame); } } } public void setGlobalData(Serializable data) { _gdata = data; } public Serializable getGlobalData() { return _gdata; } private static class ChannelFrame implements Externalizable { Class type; int id; /** External Reference Count */ int refCount; boolean replicatedSend; boolean replicatedRecv; Set<ObjectFrame> objFrames = new HashSet<ObjectFrame>(); Set<MessageFrame> msgFrames = new HashSet<MessageFrame>(); public String description; public ChannelFrame() { } public ChannelFrame(Class type, int id, String name, String description) { this.type = type; this.id = id; this.description = description; } public Integer getId() { return Integer.valueOf(id); } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { type = (Class) in.readObject(); id = in.readInt(); description = in.readUTF(); refCount = in.readInt(); replicatedSend = in.readBoolean(); replicatedRecv = in.readBoolean(); int cnt = in.readInt(); for (int i = 0; i < cnt; ++i) { objFrames.add((ObjectFrame) in.readObject()); } cnt = in.readInt(); for (int i = 0; i < cnt; ++i) { msgFrames.add((MessageFrame) in.readObject()); } } public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(type); out.writeInt(id); out.writeUTF(description == null ? "" : description); out.writeInt(refCount); out.writeBoolean(replicatedSend); out.writeBoolean(replicatedRecv); out.writeInt(objFrames.size()); for (Iterator<ObjectFrame> i = objFrames.iterator(); i.hasNext();) { out.writeObject(i.next()); } out.writeInt(msgFrames.size()); for (Iterator<MessageFrame> i = msgFrames.iterator(); i.hasNext();) out.writeObject(i.next()); } public String toString() { StringBuffer buf = new StringBuffer(32); buf.append("{CFRAME "); buf.append(type.getSimpleName()); buf.append(':'); buf.append(description); buf.append('#'); buf.append(id); buf.append(" refCount="); buf.append(refCount); buf.append(", msgs="); buf.append(msgFrames.size()); if (replicatedSend) { buf.append("R"); } buf.append(", objs="); buf.append(objFrames.size()); if (replicatedRecv) { buf.append("R"); } buf.append("}"); return buf.toString(); } } private static class CommGroupFrame implements Serializable { boolean replicated; public Set<CommFrame> commFrames = new HashSet<CommFrame>(); public CommGroupFrame(boolean replicated) { this.replicated = replicated; } } private static class CommFrame implements Externalizable { CommGroupFrame commGroupFrame; ChannelFrame channelFrame; public CommFrame() { } CommFrame(CommGroupFrame commGroupFrame, ChannelFrame channelFrame) { this.commGroupFrame = commGroupFrame; this.channelFrame = channelFrame; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { commGroupFrame = (CommGroupFrame) in.readObject(); channelFrame = (ChannelFrame) in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(commGroupFrame); out.writeObject(channelFrame); } } private static class ObjectFrame extends CommFrame implements Externalizable { private static final long serialVersionUID = -7212430608484116919L; ChannelListener _continuation; public ObjectFrame() { super(); } public ObjectFrame(CommGroupFrame commGroupFrame, ChannelFrame channelFrame, ChannelListener continuation) { super(commGroupFrame, channelFrame); this._continuation = continuation; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { super.readExternal(in); _continuation = (ChannelListener) in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { super.writeExternal(out); out.writeObject(_continuation); } } private static class MessageFrame extends CommFrame implements Externalizable { private static final long serialVersionUID = -1112437852498126297L; String method; Object[] args; public MessageFrame() { super(); } public MessageFrame(CommGroupFrame commFrame, ChannelFrame channelFrame, String method, Object[] args) { super(commFrame, channelFrame); this.method = method; this.args = args == null ? CollectionUtils.EMPTY_CLASS_ARRAY : args; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { super.readExternal(in); method = in.readUTF(); int numArgs = in.readInt(); args = new Object[numArgs]; for (int i = 0; i < numArgs; ++i) args[i] = in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { super.writeExternal(out); out.writeUTF(method); out.writeInt(args.length); for (int i = 0; i < args.length; ++i) out.writeObject(args[i]); } } /** * DOCUMENTME. * <p> * Created on Feb 16, 2004 at 8:09:48 PM. * </p> * * @author Maciej Szefler <a href="mailto:mbs@fivesight.com">mbs</a> */ private class ExecutionQueueOutputStream extends ObjectOutputStream { private Set<Object> _serializedChannels = new HashSet<Object>(); public ExecutionQueueOutputStream(OutputStream outputStream) throws IOException { super(new GZIPOutputStream(outputStream)); enableReplaceObject(true); } public Set<Object> getSerializedChannels() { return _serializedChannels; } protected void writeClassDescriptor(ObjectStreamClass desc) throws IOException { if (Serializable.class.isAssignableFrom(desc.forClass())) { writeBoolean(true); writeUTF(desc.getName()); } else { writeBoolean(false); super.writeClassDescriptor(desc); } } /** * Use this method to spy on any channels that are being serialized to * this stream. * * @param obj * @return * @throws IOException */ protected Object replaceObject(Object obj) throws IOException { if (!Serializable.class.isAssignableFrom(obj.getClass())) return null; if (obj instanceof org.apache.ode.jacob.Channel) { CommChannel commChannel = (CommChannel) ChannelFactory.getBackend((Channel) obj); _serializedChannels.add(commChannel.getId()); return new ChannelRef(commChannel.getType(), (Integer) commChannel.getId()); } else if (_replacementMap != null && _replacementMap.isReplaceable(obj)) { Object replacement = _replacementMap.getReplacement(obj); if (__log.isDebugEnabled()) __log.debug("ReplacmentMap: getReplacement(" + obj + ") = " + replacement); return replacement; } return obj; } } /** */ public class ExecutionQueueInputStream extends ObjectInputStream { private Set<CommChannel> _deserializedChannels = new HashSet<CommChannel>(); public ExecutionQueueInputStream(InputStream in) throws IOException { super(new GZIPInputStream(in)); enableResolveObject(true); } public Set<CommChannel> getSerializedChannels() { return _deserializedChannels; } protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException { return Class.forName(desc.getName(), true, _classLoader); } protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException { boolean ser = readBoolean(); if (ser) { String clsName = readUTF(); ObjectStreamClass cached = _classDescriptors.get(clsName); if (cached == null) { cached = ObjectStreamClass.lookup(Class.forName(clsName, true, _classLoader)); _classDescriptors.put(clsName, cached); } return cached; } return super.readClassDescriptor(); } protected Object resolveObject(Object obj) throws IOException { Object resolved; if (obj instanceof ChannelRef) { // We know this is a channel reference, so we have to resolve // the channel. ChannelRef oref = (ChannelRef) obj; CommChannel channel = new CommChannel(oref._type); channel.setId(oref._id); _deserializedChannels.add(channel); resolved = ChannelFactory.createChannel(channel, channel.getType()); } else if (_replacementMap != null && _replacementMap.isReplacement(obj)) { resolved = _replacementMap.getOriginal(obj); if (__log.isDebugEnabled()) { __log.debug("ReplacementMap: getOriginal(" + obj + ") = " + resolved); } } else { resolved = obj; } if (resolved != null && resolved instanceof IndexedObject) index((IndexedObject) resolved); return resolved; } } private static final class ChannelRef implements Externalizable { private Class _type; private Integer _id; private ChannelRef(Class type, Integer id) { _type = type; _id = id; } public ChannelRef() { } public boolean equals(Object obj) { return ((ChannelRef) obj)._id.equals(_id); } public int hashCode() { return _id.hashCode(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(_type); out.writeInt(_id.intValue()); } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { _type = (Class) in.readObject(); _id = Integer.valueOf(in.readInt()); } } private static final class ExecutionQueueStatistics { public long cloneClosureTimeMs; public long cloneClosureBytes; public long cloneClousreCount; public long cloneClosureReadTimeMs; public void printStatistics(PrintStream ps) { Field[] fields = getClass().getFields(); for (int i = 0; i < fields.length; ++i) { ps.print(fields[i].getName()); ps.print(" = "); try { ps.println(fields[i].get(this)); } catch (Exception ex) { ps.println(ex.toString()); } } } } }