public void DeliverSerializedMessage(SerializedMessage message, ReturnAddress from) { lock (this) { if (message.Header.SequenceNumber == this.nextSequenceNumbers[from.VertexID]) { //Console.Error.WriteLine("Delivering message {0} L = {1} A = {2}", message.Header.SequenceNumber, message.Header.Length, message.Body.Available); //foreach (Pair<Int64, Pointstamp> currentRecord in this.decoder.Elements(message)) // Console.Error.WriteLine("-- {0}", currentRecord); //this.nextSequenceNumber++; this.nextSequenceNumbers[from.VertexID]++; foreach (var typedMessage in this.decoder.AsTypedMessages(message)) { this.consumer.ProcessCountChange(typedMessage); typedMessage.Release(); } this.Flush(from); } else { //Console.Error.WriteLine("Discarding message {0} (expecting {1}) L = {2} A = {3}", message.Header.SequenceNumber, this.nextSequenceNumber, message.Header.Length, message.Body.Available); //foreach (Pair<Int64, Pointstamp> currentRecord in this.decoder.Elements(message)) // Console.Error.WriteLine("-- {0}", currentRecord); } } }
public void Send(Message <S, T> message, ReturnAddress from) { this.encodersFromLocalVertices[from.ThreadIndex].SetCurrentTime(message.time); this.encodersFromLocalVertices[from.ThreadIndex].Write(new ArraySegment <S>(message.payload, 0, message.length), from.VertexID); //for (int i = 0; i < message.length; ++i) // this.encodersFromLocalVertices[from.ThreadIndex].Write(message.payload[i], from.VertexID); }
internal static Value Make(ReturnAddress ra) { Value result = value; result.Kind = Kinds.ReturnAddress; result.returnAddressValue = ra; return(result); }
public async Task <Result> ConfirmApply([FromBody] AdminRefundConfirmApplyRequest request) { var returnApply = await _returnApplyRepository.Query() .Include(e => e.OrderItem) .FirstOrDefaultAsync(e => e.Id == request.Id); if (returnApply == null) { return(Result.Fail(ResultCodes.IdInvalid)); } if (returnApply.Status != ReturnAuditStatus.NotAudit) { return(Result.Fail(ResultCodes.RequestParamError, "当前申请不允许修改状态")); } var address = await _addressRepository.Query() .Include(e => e.Province) .Include(e => e.City) .Include(e => e.Area) .FirstOrDefaultAsync(e => e.Id == request.RefundAddressId); if (address == null) { return(Result.Fail(ResultCodes.RequestParamError, "无效地址")); } var returnAddress = new ReturnAddress { ReturnApplyId = returnApply.Id, AreaName = address.Area.Name, CityName = address.City.Name, Createat = DateTime.Now, DetailInfo = address.DetailInfo, PostalCode = address.PostalCode.ToString(), ProvinceName = address.Province.Name, Remarks = request.Remarks, TelNumber = address.TelNumber, UserName = address.UserName, }; returnApply.Status = ReturnAuditStatus.Agree; returnApply.AuditMessage = request.Remarks; returnApply.AuditTime = DateTime.Now; returnApply.OrderItem.Status = OrderItemStatus.ConfirmApply; _returnApplyRepository.Update(returnApply, false); using (var transaction = _returnApplyRepository.BeginTransaction()) { await _returnApplyRepository.SaveAsync(); await _refundAddressRepository.InsertAsync(returnAddress); transaction.Commit(); } return(Result.Ok()); }
public void DeliverSerializedMessage(SerializedMessage message, ReturnAddress from) { foreach (var typedMessage in this.decoder.AsTypedMessages(message)) { this.consumer.ProcessCountChange(typedMessage); typedMessage.Release(); } this.Flush(from); }
public void OnReceive(Message <string, IterationIn <T> > message, ReturnAddress sender) { var stripped = new Pair <string, T> [message.length]; for (int i = 0; i < message.length; i++) { stripped[i].First = message.payload[i]; stripped[i].Second = message.time.outerTime; } Context.Reporting.ForwardLog(stripped); }
ReturnAddress RebuildReturnAddress( object[] objects, int index, Composite composite, Func <int, object> reader) { var result = new ReturnAddress(); objects [index] = result; result.Environment = (VmEnvironment)reader(composite.Elements [0]); result.ProgramCounter = (int)(long)reader(composite.Elements [1]); return(result); }
int SerializeReturnAddress(ReturnAddress returnAddress, object obj) { var composite = new Composite { Kind = ObjectTypes.ReturnAddress, Elements = new int[2] }; var result = SerializeOneHashed(composite, obj); composite.Elements [0] = Serialize(returnAddress.Environment); composite.Elements [1] = SerializeOne(returnAddress.ProgramCounter); return(result); }
/// <summary> /// Returns a hash code for this instance. /// </summary> /// <returns>A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.</returns> public override int GetHashCode() { unchecked { var hashCode = StackPointer.GetHashCode(); hashCode = (hashCode * 397) ^ ReturnAddress.GetHashCode(); hashCode = (hashCode * 397) ^ (Module != null ? Module.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (FunctionName != null ? FunctionName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (int)Offset; return(hashCode); } }
public Postbox(int channelID, VertexOutput <S, T> sender, StageInput <S, T> receiverBundle, Mailbox <S, T>[] mailboxes, Action <S[], int[], int> routingHashcodeFunction, NetworkChannel networkChannel) { this.threadindex = sender.Vertex.Scheduler.Index; this.channelID = channelID; this.sender = sender; this.vertexid = sender.Vertex.VertexId; this.receiverBundle = receiverBundle; this.routingHashcodesFunction = routingHashcodeFunction; this.networkChannel = networkChannel; this.mailboxes = mailboxes; this.returnAddress = new ReturnAddress(this.ProcessID, this.vertexid, this.threadindex); }
public ActionResult Back() { ReturnAddress WhereToGo = Session.PopReturnAddress(); if (WhereToGo.Controller == null) { return(RedirectToAction(WhereToGo.Module)); } else { return(RedirectToAction(WhereToGo.Module, WhereToGo.Controller)); } }
private void PostBufferAndPossiblyCutThrough(ReturnAddress from) { // no matter what, post the buffer and refresh local storage. this.Post(this.messagesFromLocalVertices[from.ThreadIndex]); this.messagesFromLocalVertices[from.ThreadIndex] = new Message <S, T>(); // we may want to cut-through. if (this.endpoint.Vertex.Scheduler.Index == from.ThreadIndex && this.endpoint.AvailableEntrancy >= 0) { this.endpoint.AvailableEntrancy = this.endpoint.AvailableEntrancy - 1; this.Drain(); this.endpoint.AvailableEntrancy = this.endpoint.AvailableEntrancy + 1; } }
public Postbox(int channelID, VertexOutput <S, T> sender, StageInput <S, T> receiverBundle, Mailbox <S, T>[] mailboxes, Func <S, int> routingHashcodeFunction, NetworkChannel networkChannel) { this.threadindex = sender.Vertex.Scheduler.Index; this.channelID = channelID; this.sender = sender; this.vertexid = sender.Vertex.VertexId; this.receiverBundle = receiverBundle; this.routingHashcodeFunction = routingHashcodeFunction; this.networkChannel = networkChannel; this.mailboxes = mailboxes; this.returnAddress = new ReturnAddress(this.ProcessID, this.vertexid, this.threadindex); this.localTempBuffer = new Message <S, T>(); //this.sendSequenceNumbers = new int[Naiad.Processes, this.receiverBundle.LocalParallelism]; }
/// <summary> /// Enqueues the incoming network message on the shared queue, called by the network channel. /// </summary> /// <param name="message">message</param> /// <param name="from">sender</param> public override void DeliverSerializedMessage(SerializedMessage message, ReturnAddress from) { this.sharedSerializedQueue.Enqueue(message); if (this.sharedSerializedQueue.Count > SerializedQueueHighWatermark) { SerializedQueueHighWatermark *= 2; } if (!this.dirty) { this.dirty = true; } this.postOffice.Signal(); }
/// <summary> /// Compare addresses to see if they have the same delivery point and carrier route. /// Returns address provided by the US Postal Service with the delivery point and carrier route /// </summary> /// <param name="addr1">Address 1</param> /// <param name="addr2">Address 1</param> /// <param name="returnAddr1">USPS Address 1</param> /// <param name="returnAddr2">USPS Address 2</param> /// <returns>boolean</returns> public bool Compare(Address addr1, Address addr2, out ReturnAddress returnAddr1, out ReturnAddress returnAddr2) { bool retVal = false; //Normalize the addresses returnAddr1 = Normalize(addr1); returnAddr2 = Normalize(addr2); //Compare the data if (returnAddr1 != null && returnAddr2 != null) { if (returnAddr1.DeliveryPoint == returnAddr2.DeliveryPoint && returnAddr1.CarrierRoute == returnAddr2.CarrierRoute) retVal = true; } return retVal; }
/// <summary> /// Flushes the queue of local messages. /// Called by the postbox. /// </summary> /// <param name="from">Postbox of the upstream operator</param> public override void Flush(ReturnAddress from) { if (this.messagesFromLocalVertices[from.ThreadIndex].length > 0) { this.PostBufferAndPossiblyCutThrough(from); } // XXX : Assumes placement is the same, which is brittle if (this.VertexId == from.VertexID) { if (this.endpoint.AvailableEntrancy >= 0) { this.endpoint.AvailableEntrancy = this.endpoint.AvailableEntrancy - 1; endpoint.Flush(); this.endpoint.AvailableEntrancy = this.endpoint.AvailableEntrancy + 1; } this.progressBuffer.Flush(); } }
/// <summary> /// Flushes the queue of local messages. /// Called by the postbox. /// </summary> /// <param name="from">Postbox of the upstream operator</param> public override void Flush(ReturnAddress from) { if (this.messagesFromLocalVertices[from.ThreadIndex].length > 0) { this.PostBufferAndPossiblyCutThrough(from); } // If we are running on the same thread, the flush can be delivered directly. if (this.endpoint.Vertex.Scheduler.Index == from.ThreadIndex) { if (this.endpoint.AvailableEntrancy >= 0) { this.endpoint.AvailableEntrancy = this.endpoint.AvailableEntrancy - 1; endpoint.Flush(); this.endpoint.AvailableEntrancy = this.endpoint.AvailableEntrancy + 1; } this.progressBuffer.Flush(); } }
private bool run(LabelInst label) { if (InitStack == null) { MessageBox.Show("Initial stack has not been set yet!", "StackFish", MessageBoxButtons.OK, MessageBoxIcon.Warning); return(false); } // Recreate return address to rename callee to current label & set return address -1 StackItem lastItem = InitStack[InitStack.Count - 1]; if (lastItem is ReturnAddress) { ReturnAddress ra = lastItem as ReturnAddress; InitStack[InitStack.Count - 1] = new ReturnAddress(ra.CallerName, label.Name, -1); } // Create simulator this.simulator = new Simulator(file, InitStack); // TODO initial registers simulator.OnInstructionReady += Simulator_OnInstructionReady; simulator.Registers.OnRegisterChanged += Registers_OnRegisterChanged; simulator.Registers.OnPointerChanged += Registers_OnPointerChanged; simulator.Registers.OnFlagChanged += Registers_OnFlagChanged; simulator.Stack.OnStackChanged += Stack_OnStackChanged; simulator.Start(label.Index); // Update controls startToolStripMenuItem.Visible = false; runningToolStripMenuItem.Visible = true; updateRegisters(); updateFlags(); drawStack(); executed = 0; updateExecuted(); setStatus("Started at " + label.Name + "! Press F5 to step forward, Shift+F5 to step backward"); return(true); }
public override void Send(Message <S, T> records, ReturnAddress from) { for (int i = 0; i < records.length; i++) { // Message has been disabled to conserve memory. if (this.messagesFromLocalVertices[from.ThreadIndex].Unallocated) { this.messagesFromLocalVertices[from.ThreadIndex].Allocate(); this.messagesFromLocalVertices[from.ThreadIndex].time = records.time; } // we may need to flush the buffered message because it has a different time. if (!this.messagesFromLocalVertices[from.ThreadIndex].time.Equals(records.time)) { PostBufferAndPossiblyCutThrough(from); // it is possible that cut through (and re-entrancy) results in records still present here. if (!this.messagesFromLocalVertices[from.ThreadIndex].Unallocated) { this.Post(this.messagesFromLocalVertices[from.ThreadIndex]); this.messagesFromLocalVertices[from.ThreadIndex] = new Message <S, T>(); } this.messagesFromLocalVertices[from.ThreadIndex].Allocate(); this.messagesFromLocalVertices[from.ThreadIndex].time = records.time; } // actually put the record into the buffer this.messagesFromLocalVertices[from.ThreadIndex].payload[this.messagesFromLocalVertices[from.ThreadIndex].length++] = records.payload[i]; // if the buffer is now full, might as well ship the data [and consider cutting through to other dataflow vertices] if (this.messagesFromLocalVertices[from.ThreadIndex].length == this.messagesFromLocalVertices[from.ThreadIndex].payload.Length) { PostBufferAndPossiblyCutThrough(from); } } }
public void Flush(ReturnAddress from) { this.encodersFromLocalVertices[from.ThreadIndex].Flush(); }
public void Send(Message <Update, Empty> message, ReturnAddress from) { this.recordsReceived += message.length; this.consumer.scheduler.statistics[(int)RuntimeStatistic.ProgressLocalRecords] += message.length; this.consumer.ProcessCountChange(message); }
public void Send(Pair <S, T> record, ReturnAddress from) { this.encodersFromLocalVertices[from.ThreadIndex].Write(record, from.VertexID); }
public void Flush(ReturnAddress from) { }
public void RequestFlush(ReturnAddress from) { }
public void ForwardDoubleAggregate(Message <Pair <string, ReportingRecord <double> >, IterationIn <T> > message, ReturnAddress sender) { for (int i = 0; i < message.length; ++i) { ReportingRecord <double> r = message.payload[i].Second; Context.Reporting.LogAggregate(message.payload[i].First, r.type, r.payload, r.count, message.time.outerTime); } }
public abstract void DeliverSerializedMessage(SerializedMessage message, ReturnAddress from);
/// <summary> /// Create a new job in the Windows Azure Import/Export service. /// </summary> /// <param name="jobName">Name of the job.</param> /// <param name="configFilePath"></param> public void CreateJob(string jobName, string configFilePath) { var XConf = XDocument.Load(configFilePath); // ReturnAddress: Specifies the return address information for the job. var XReturnAddress = XConf.Descendants("ReturnAddress").First(); var returnAddress = new ReturnAddress( XReturnAddress.Element("Name").Value, XReturnAddress.Element("Address").Value, XReturnAddress.Element("Phone").Value, XReturnAddress.Element("Email").Value ); // ReturnShipping: Specifies the return carrier and customer’s account with the carrier var XReturnShipping = XConf.Descendants("ReturnShipping").First(); var returnShipping = new ReturnShipping( XReturnShipping.Element("CarrierName").Value, XReturnShipping.Element("CarrierAccountNumber").Value ); // Properties: The list of properties for the job. // refer to https://msdn.microsoft.com/en-us/library/azure/dn529110.aspx for more details var XJobProperty = XConf.Descendants("JobProperty").First(); var putJobProperties = new PutJobProperties( backupDriveManifest: bool.Parse(XJobProperty.Element("BackupDriveManifest").Value), description: XJobProperty.Element("Description").Value, enableVerboseLog: bool.Parse(XJobProperty.Element("EnableVerboseLog").Value), friendlyName: XJobProperty.Element("FriendlyName").Value, type: (XJobProperty.Element("JobType").Value.Equals("Import", StringComparison.InvariantCultureIgnoreCase)? JobType.Import: JobType.Export), location: XJobProperty.Element("Location").Value, storageAccountKey: XJobProperty.Element("StorageAccountKey").Value, storageAccountName: XJobProperty.Element("StorageAccountName").Value, importExportStatesPath: XJobProperty.Element("ImportExportStatesPath").Value, returnAddress: returnAddress, returnShipping: returnShipping ); // must include either StorageAccountKey or ContainerSas in the request if (string.IsNullOrEmpty(XJobProperty.Element("StorageAccountKey").Value)) { putJobProperties.StorageAccountKey = null; putJobProperties.ContainerSas = XJobProperty.Element("ContainerSas").Value; } var putJobParameters = new PutJobParameters(jobName, putJobProperties); if (putJobProperties.Type == JobType.Export) { // BlobList: contain information about the blobs to be exported for an export job. var XBlobList = XConf.Descendants("BlobList").First().Elements(); var blobList = new BlobList(new List <string>(), new List <string>()); foreach (var XBlob in XBlobList) { if (!String.IsNullOrWhiteSpace(XBlob.Attribute("BlobPaths").Value)) { blobList.BlobPath.Add(XBlob.Attribute("BlobPaths").Value); } if (!String.IsNullOrWhiteSpace(XBlob.Attribute("BlobPathPrefixes").Value)) { blobList.BlobPathPrefix.Add(XBlob.Attribute("BlobPathPrefixes").Value); } } putJobParameters.Export = new Export(blobList: blobList); } else { // DriveList: List of up to ten drives that comprise the job. var XDriveList = XConf.Descendants("DriveList").First().Elements(); var driveList = new List <Drive>(); foreach (var XDrive in XDriveList) { driveList.Add(new Drive( driveId: XDrive.Element("DriveId").Value, bitLockerKey: XDrive.Element("BitLockerKey").Value, manifestFile: XDrive.Element("ManifestFile").Value, manifestHash: XDrive.Element("ManifestHash").Value )); } putJobParameters.DriveList = driveList; } client.PutJob(XJobProperty.Element("StorageAccountName").Value, jobName, putJobParameters); }
public abstract void Flush(ReturnAddress from);
public abstract void Send(Message <S, T> message, ReturnAddress from);
public Val(ReturnAddress value) : this() { type = Type.ReturnAddress; vreturn = value; }
public void DeliverSerializedMessage(SerializedMessage message, ReturnAddress from) { throw new NotImplementedException("Attempted to deliver message from a remote sender to a remote recipient, which is not currently supported."); }