internal virtual void Put(Packet x) { _array[_sendPtr] = x; if (++_sendPtr >= _array.Length) _sendPtr = 0; IncUsedSlots(); }
public override void Execute() /* throws Throwable */ { Packet p; int i = 0, j, k, n; Packet[] array = new Packet[9999]; while ((p = _inport.Receive()) != null) { array[i] = p; // Console.WriteLine("in: " + p.GetContent()); ++i; } Console.Out.WriteLine("No. of elements:" + i); j = 0; k = i; n = k; string t = null; while (n > 0) { t = null; for (i = 0; i < k; ++i) { if (array[i] != null) { string s = (string)array[i].Content; if (t == null || (String.Compare(s, t) < 0)) { j = i; t = (string)array[j].Content; } } } _outport.Send(array[j]); array[j] = null; --n; } }
/// <summary>Detach Packet from named chain /// </summary> internal virtual bool Detach(string name, Packet subordinate) { if (_chains == null) return false; Chain chain = (Chain)(_chains[name]); if (chain == null) return false; if (!(chain.Members.Contains(subordinate))) return false; chain.Members.Remove(subordinate); //Packet root = Root; //subordinate.Owner = root._owner; return true; }
/// <summary>Maintains a Chain of Packets attached to this Packet. /// A Packet may have multiple named Chains attached to it, accessed via a Hashtable. /// Since Packets are attached to Chains, as well as Chains to Packets, /// this results in an alternation of Packets and Chains, creating a tree structure. /// </summary> internal virtual void Attach(string name, Packet subordinate) { if (subordinate == null) { FlowError.Complain("Null packet reference in 'Attach' method call"); } Packet p = this; while (p._owner is Packet) { if (p == subordinate) { FlowError.Complain("Loop in tree structure"); } p = (Packet) p._owner; } if (p == subordinate) { FlowError.Complain("Loop in tree structure"); } if (p._owner != Thread.CurrentThread) { FlowError.Complain("Packet not owned (directly or indirectly) by current component"); } if (subordinate._owner != Thread.CurrentThread) { FlowError.Complain("Subordinate packet not owned by current component"); } if (_chains == null) _chains = new Dictionary<string, Chain>(); Chain chain = (Chain)(_chains[name]); if (chain == null) { chain = new Chain(name); _chains.Add(name, chain); } subordinate.Owner = this; chain.Members.Add(subordinate); }
/// <summary>The receive function of an InitializationConection. /// Returns null after the packet has been delivered (because packet is set to null). /// You get one copy per activation /// * /// Warning: the object contained in this packet must not be modified. /// * /// See IInputPort.receive. /// </summary> public Packet Receive() { if (IsClosed()) return null; else { Interlocked.Increment(ref Network.receives); Packet p = new Packet(_receiver); p._content = _content; _receiver._mother.Trace("{0}: IIP received: {1}", Name, p); Close(); // is needed! return p; } }
/// <summary> Send a packet to this Port. /// The thread is suspended if no capacity is currently available. /// If the port or connection has been closed, <code>false</code> is /// returned; otherwise, <code>true</code> is returned. /// <p> Do not reference the packet after sending - someone else may be /// modifying it! /// </summary> /// <param name="packet">packet to send /// </param> /// <returns>true if successful /// * /// </returns> // The send function. public virtual void Send(Packet packet) { bool res = true; Trace("Sending: " + packet.ToString()); _sender.CheckOwner(packet); if (isClosed) { Trace("Sending - port closed"); res = false; } res &= _cnxt.Send(packet, this); // fire up send method on connection if (!res) FlowError.Complain("Could not deliver packet to " + Name); Trace("Sent OK"); return; }
/// <summary>The send function. See OutputPort.send. /// </summary> //UPGRADE_NOTE: Synchronized keyword was removed from method 'send'. Lock expression was added. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1027"' internal bool Send(Packet packet, OutputPort op) { lock (this) { if (packet == null) throw new System.ArgumentException(); _sender = op._sender; if (IsClosed()) { return false; } //_sender._mother.Trace(Name + ": Sending: " + packet); if (IsEmpty()) System.Threading.Monitor.PulseAll(this); while (IsFull()) { if (_dropOldest) { Packet p = _buffer.Take(); Interlocked.Increment(ref Network.dropOlds); _sender._mother.Trace("{0}: DropOldest", _sender.Name); } else { _sender.Status = Component.States.SuspSend; _sender._mother.Trace("{0}: Send/susp", _sender.Name); try { System.Threading.Monitor.Wait(this); } catch (System.Threading.ThreadInterruptedException e) { //UPGRADE_NOTE: Exception 'java.lang.ThreadDeath' was converted to ' ' which has different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1100"' // throw new System.ApplicationException(); IndicateOneSenderClosed(); FlowError.Complain(_sender._name + ": interrupted"); // unreachable code return false; } // if (Component._network._deadlock) //{ // _sender._thread.Interrupt(); // _sender._mother.Trace(_sender._name + ": Send interrupted because of deadlock"); // // unreachable code // return false; // } _sender = op._sender; _sender.Status = Component.States.Active; _sender._mother.Trace("{0}: Send/resume", _sender.Name); } } if (IsClosed()) { _sender._mother.Trace("{0}: Send/close", _sender.Name); //Interlocked.Increment(ref Network.sends); return false; } //lock ((_receiver._inputPorts as ICollection).SyncRoot) try { Monitor.Enter(_receiver._lockObject); packet.ClearOwner(); _buffer.Put(packet); if (_receiver.Status == Component.States.Dormant || _receiver.Status == Component.States.NotStarted) _receiver.Activate(); else System.Threading.Monitor.PulseAll(this); _sender._network._active = true; _sender = null; } catch (ThreadInterruptedException e) { return false; } finally { Monitor.Exit(_receiver._lockObject); } Interlocked.Increment(ref Network.sends); return true; } }
/// <summary> This method returns the downstream Packet count for a given OutputPort /// It is normally only used by Components that do load balancing. /// </summary> /// <returns>int /// /// </returns> //internal int downstreamCount() // { // return _cnxt.Count(); // } /// <summary> Send a packet to this Port. /// The thread is suspended if no capacity is currently available. /// If the port or connection has been closed, <code>false</code> is /// returned; otherwise, <code>true</code> is returned. /// <p> Do not reference the packet after sending - someone else may be /// modifying it! /// </summary> /// <param name="packet">packet to send /// </param> /// <returns>true if successful /// * /// </returns> // The send function. public override void Send(Packet packet) { //_sender.Drop(packet); -- do nothing - changed Aug. 5, 2014 }