public Task Handle(PlaceOrder message, IMessageHandlerContext context) { _processingCount++; _log.Info($"RECV {nameof(PlaceOrder)} [{_processingCount}], {nameof(message.Id)}: {message.Id}"); var orderPlaced = new OrderPlaced { OrderId = message.Id, IsGrouped = message.IsGrouped }; var task = context.Publish(orderPlaced); _log.Info($"POST {nameof(OrderPlaced)} [{_processingCount}], {nameof(orderPlaced.OrderId)}: {orderPlaced.OrderId}"); if (message.IsGrouped != _groupItems) { // Grouping completed. if (_groupItems) { _groupItems = false; _log.Info(_sw.LogTimeToMessage("GROUP COMPLETE ")); } // Grouping started; else { _groupItems = true; _sw = StopwatchExtensions.CreateStartSW(); } } return(task); }
public async Task Consume(ConsumeContext <IPlaceOrderCommand> context) { _processingCount++; // TODO: Need to determine MassTransit logging services and not use console. await Console.Out.WriteLineAsync($"RECV {nameof(IPlaceOrderCommand)} [{_processingCount}], {nameof(context.Message.Id)}: {context.Message.Id}"); //notify subscribers that a order is registered await context.Publish <IOrderPlacedEvent>(new { OrderId = context.Message.Id, context.Message.IsGrouped }); await Console.Out.WriteLineAsync($"POST {nameof(IOrderPlacedEvent)} [{_processingCount}], {nameof(IOrderPlacedEvent.OrderId)}: {context.Message.Id}"); if (context.Message.IsGrouped != _groupItems) { // Grouping completed. if (_groupItems) { _groupItems = false; _sw.LogTimeToConsole("GROUP COMPLETE "); } // Grouping started; else { _groupItems = true; _sw = StopwatchExtensions.CreateStartSW(); } } }
private void DoAnalogKeyDown(object sender, DoWorkEventArgs args) { var watch = new Stopwatch(); var parameters = args.Argument; var worker = sender as BackgroundWorker; var key = (VirtualKeyCode)((Object[])parameters)[0]; var amount = (double)((Object[])parameters)[1]; var onTime = TimeSpan.FromTicks(StopwatchExtensions.NanoSecondsToTicks((long)(this.PwmIntervalNanoseconds * amount))); var offTime = TimeSpan.FromTicks(StopwatchExtensions.NanoSecondsToTicks((long)(this.PwmIntervalNanoseconds))).Subtract(onTime); args.Result = key; while (!worker.CancellationPending) { GameWindow.WaitForFocus(); this.KeyDown(key); Thread.Sleep(onTime); this.KeyUp(key); Thread.Sleep(offTime); } args.Cancel = true; }
public static StopwatchExtensions.TimedThreadedExecutionSummary ExecuteThreaded (Action action, int iterations = 1, TimeSpan?maxAverage = null, TimeSpan?maxTotal = null, bool timeIndividualExecutions = false, string description = "", string timeFormat = DefaultTimeFormat, int maxTries = 3) { maxAverage = maxAverage != default(TimeSpan) ? maxAverage : TimeSpan.MaxValue; maxTotal = maxTotal != default(TimeSpan) ? maxTotal : TimeSpan.MaxValue; StopwatchExtensions.TimedThreadedExecutionSummary executionSummary = null; Func <TimeSpan?, string> format = date => date?.ToString(timeFormat) ?? ""; Action printResults = () => { PrintSummary(iterations, maxAverage, maxTotal, description, format, executionSummary); Console.WriteLine( $@" Individual execution times Average: {format(executionSummary.IndividualExecutionTimes.Average())} Min: {format(executionSummary.IndividualExecutionTimes.Min())} Max: {format(executionSummary.IndividualExecutionTimes.Max())} Sum: {format(executionSummary.IndividualExecutionTimes.Sum())}"); }; for (int tries = 1; tries <= maxTries; tries++) { executionSummary = StopwatchExtensions.TimeExecutionThreaded(action: action, iterations: iterations, timeIndividualExecutions: timeIndividualExecutions); try { RunAsserts(maxAverage, maxTotal, executionSummary, format); } catch (Exception e) { Debug.WriteLine($"Try: {tries} {e.GetType().FullName}: {e.Message}"); if (tries >= maxTries) { printResults(); throw; } continue; } printResults(); break; } printResults(); RunAsserts(maxAverage, maxTotal, executionSummary, format); return(executionSummary); }
public void RunTest() { var ts = StopwatchExtensions.Run(s => { Thread.Sleep(100); return(s.ElapsedMilliseconds); }); Assert.True(ts >= 100); }
public Int32 CalculateFps() { long totalTime = 0; for (int i = 0; i < history.Length; i++) { totalTime += history[i]; } return((Int32)(history.Length * 1000d / (Double)StopwatchExtensions.StopwatchTicksAsDoubleMilliseconds(totalTime))); }
/// <summary> /// Handles GPIO changes (rising and falling PPM signal), recording them to the decoder queue. /// </summary> /// <param name="sender">Event source, the <see cref="GpioPin"/> which changed.</param> /// <param name="arguments">Information about the GPIO pin value change.</param> /// <remarks> /// Main hardware routine which triggers the input translation process. /// This code must run as quickly as possible else we could miss the next event! /// </remarks> private void OnInputPinValueChanged(GpioPin sender, GpioPinValueChangedEventArgs arguments) { // Get PPM value var time = StopwatchExtensions.GetTimestampInMicroseconds(); var level = arguments.Edge == GpioPinEdge.RisingEdge; var value = new PpmPulse(time, level); // Queue for processing _pulseBuffer.Enqueue(value); _pulseTrigger.Set(); }
private async Task SubmitSnippetPostFeedback(string snippetId, string connectionId, long startTimestamp) { SnippetResult result; try { result = await hostConnector.RunSnippetAsync(snippetId); } catch (Exception ex) { result = new SnippetResult() { status = SnippetStatus.InitializationError, exception = ex.Message }; } var hubContext = GlobalHost.ConnectionManager.GetHubContext <ResultHub>(); result.totalTime = StopwatchExtensions.GetTimestampMillis() - startTimestamp; hubContext.Clients.Client(connectionId).SendResult(connectionId, snippetId, result, result.status.ToHealth().ToColor()); }
public void Concurrent_read_only_access_to_aggregate_history_can_occur_in_paralell() { var user = new User(); user.Register("*****@*****.**", "password", Guid.NewGuid()); using (var session = OpenSession(CreateStore())) { session.Save(user); } var iterations = 20; var delayEachTransactionByMilliseconds = 100; Action readUserHistory = () => { using (var session = OpenSession(CreateStore())) { using (var transaction = new TransactionScope()) { ((IEventStoreReader)session).GetHistory(user.Id); Thread.Sleep(TimeSpanExtensions.Milliseconds(delayEachTransactionByMilliseconds)); transaction.Complete(); } } }; readUserHistory();//one warmup to get consistent times later. var timeForSingleTransactionalRead = (int)StopwatchExtensions.TimeExecution(readUserHistory).TotalMilliseconds; var timingsSummary = TimeAsserter.ExecuteThreaded( readUserHistory, iterations: iterations, timeIndividualExecutions: true, maxTotal: ((iterations * timeForSingleTransactionalRead) / 2).Milliseconds(), description: $"If access is serialized the time will be approximately {iterations * timeForSingleTransactionalRead} milliseconds. If parelellized it should be far below this value."); timingsSummary.Average.Should().BeLessThan(delayEachTransactionByMilliseconds.Milliseconds()); timingsSummary.IndividualExecutionTimes.Sum().Should().BeGreaterThan(timingsSummary.Total); }
public async Task Consume(ConsumeContext <IOrderPlacedEvent> context) { _processingCount++; // TODO: Need to determine MassTransit logging services and not use console. await Console.Out.WriteLineAsync($"RECV {nameof(IOrderPlacedEvent)} [{_processingCount}], {nameof(context.Message.OrderId)}: {context.Message.OrderId}"); if (context.Message.IsGrouped != _groupItems) { // Grouping completed. if (_groupItems) { _groupItems = false; _sw.LogTimeToConsole("GROUP COMPLETE "); } // Grouping started; else { _groupItems = true; _sw = StopwatchExtensions.CreateStartSW(); } } }
public static StopwatchExtensions.TimedExecutionSummary Execute (Action action, int iterations = 1, TimeSpan?maxAverage = null, TimeSpan?maxTotal = null, string description = "", string timeFormat = DefaultTimeFormat, int maxTries = 3) { maxAverage = maxAverage != default(TimeSpan) ? maxAverage : TimeSpan.MaxValue; maxTotal = maxTotal != default(TimeSpan) ? maxTotal : TimeSpan.MaxValue; Func <TimeSpan?, string> format = date => date?.ToString(timeFormat) ?? ""; StopwatchExtensions.TimedExecutionSummary executionSummary = null; for (int tries = 1; tries <= maxTries; tries++) { executionSummary = StopwatchExtensions.TimeExecution(action: action, iterations: iterations); try { RunAsserts(maxAverage, maxTotal, executionSummary, format); } catch (Exception e) { Debug.WriteLine($"Try: {tries} {e.GetType().FullName}: {e.Message}"); if (tries >= maxTries) { PrintSummary(iterations, maxAverage, maxTotal, description, format, executionSummary); throw; } continue; } PrintSummary(iterations, maxAverage, maxTotal, description, format, executionSummary); break; } return(executionSummary); }
public async Task <ActionResult> SubmitRequest(string snippetId, string connectionId) { long startTimestamp = StopwatchExtensions.GetTimestampMillis(); if (String.IsNullOrEmpty(snippetId)) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } if (connectionId != null) { Task.Run(() => SubmitSnippetPostFeedback(snippetId, connectionId, startTimestamp)).FireAndForget(); return(new HttpStatusCodeResult(HttpStatusCode.Accepted)); } else { SnippetResult result = await hostConnector.RunSnippetAsync(snippetId); result.totalTime = StopwatchExtensions.GetTimestampMillis() - startTimestamp; Response.StatusCode = (int)HttpStatusCode.OK; return(Json(new { connectionId = connectionId, message = result, newStatus = result.status.ToHealth().ToColor() })); } }
private static async Task SendOrders(IMessageSession endpointInstance) { Console.WriteLine("Press enter to send 1 message or a number + enter to send X messages."); Console.WriteLine("Type 'exit' to exit"); Console.WriteLine(); while (true) { var keys = Console.ReadLine(); int count; if (keys == "") { count = 1; } else if (string.Compare(keys, "exit", StringComparison.InvariantCultureIgnoreCase) == 0) { return; } else { if (!int.TryParse(keys, out count)) { await Console.Out.WriteLineAsync("Keys Not Recognized."); } } var sw = StopwatchExtensions.CreateStartSW(); for (var inc = 0; inc < count; inc++) { await SendOrder(endpointInstance, count > 1 && inc != count - 1); } if (count > 1) { await sw.LogTimeToConsoleAsync($"GROUP COMPLETE "); } } }
public Task Handle(OrderPlaced message, IMessageHandlerContext context) { _processingCount++; _log.Info($"RECV {nameof(OrderPlaced)} [{_processingCount}], {nameof(message.OrderId)}: {message.OrderId}"); if (message.IsGrouped != _groupItems) { // Grouping completed. if (_groupItems) { _groupItems = false; _log.Info(_sw.LogTimeToMessage("GROUP COMPLETE ")); } // Grouping started; else { _groupItems = true; _sw = StopwatchExtensions.CreateStartSW(); } } return(Task.CompletedTask); }
private void WatchdogThreadFunc() { while (!isExiting) { // This is a watchdog; it does not need to be precise. // It can be improved by recomputing the next check time (i.e. when a snippet expires) // at each submission, but for now we are good. // We sleep for a while, than check try { //Thread.Sleep(1000); HostEvent hostEvent; if (defaultDomainManager.GetHostMessage(1000, out hostEvent)) { System.Diagnostics.Debug.WriteLine("Watchdog: message from host for AppDomain " + hostEvent.appDomainId); // Process event switch ((HostEventType)hostEvent.eventType) { case HostEventType.OutOfTasks: { PooledDomainData poolDomain = FindByAppDomainId(hostEvent.appDomainId); if (poolDomain != null) { if (Interlocked.CompareExchange(ref poolDomain.isAborting, 1, 0) == 0) { poolDomain.mainThread.Abort(threadsExaustedAbortToken); } } } break; } } else { long currentTime = StopwatchExtensions.GetTimestampMillis(); //System.Diagnostics.Debug.WriteLine("Watchdog: check at " + currentTime); for (int i = 0; i < NumberOfDomainsInPool; ++i) { // Something is running? PooledDomainData poolDomain = null; lock (poolLock) { poolDomain = poolDomains[i]; } if (poolDomain != null) { long snippetStartTime = Thread.VolatileRead(ref poolDomain.timeOfSubmission); if (snippetStartTime > 0) { // For too long? long millisRunning = currentTime - snippetStartTime; if (millisRunning > runningThreshold) { // Abort Thread i / Unload domain i // Calling abort here is fine: the host will escalate it for us if it times // out. Otherwise, we can still catch it and reuse the AppDomain System.Diagnostics.Debug.WriteLine("Timeout: aborting thread #{0} in domain {1} ({2} ms)", i, poolDomains[i].domainId, millisRunning); // Avoid to call Abort twice Thread.VolatileWrite(ref poolDomains[i].timeOfSubmission, 0); poolDomains[i].mainThread.Abort(timeoutAbortToken); } // Check also for appDomain.MonitoringTotalProcessorTime //else if (poolDomains[i].appDomain.MonitoringTotalProcessorTime > MaxCpuTime) // //TODO //} } // If our thread was aborted rudely, we need to create a new one if (poolDomain.mainThread == null || poolDomain.mainThread.ThreadState == System.Threading.ThreadState.Aborted) { defaultDomainManager.HostUnloadDomain(poolDomain.domainId); poolDomains[i] = new PooledDomainData(); var thread = CreateDomainThread(i); thread.Start(); } } } } // Ensure there is at least a thread in the pool if (numberOfThreadsInPool < 1) { poolDomains[0] = new PooledDomainData(); var thread = CreateDomainThread(0); thread.Start(); } } catch (ThreadInterruptedException) { // Do we need to exit? Simply cycle back to check exit status } } }
void RPCServerUpdate() { rpcTimer.Reset(); rpcTimer.Start(); rpcPollTimeout.Reset(); rpcPollTimer.Reset(); rpcExecTimer.Reset(); var config = Configuration.Instance; long maxTimePerUpdateTicks = StopwatchExtensions.MicrosecondsToTicks(config.MaxTimePerUpdate); long recvTimeoutTicks = StopwatchExtensions.MicrosecondsToTicks(config.RecvTimeout); ulong rpcsExecuted = 0; rpcYieldedContinuations.Clear(); for (int i = 0; i < Servers.Count; i++) { Servers [i].RPCServer.Update(); } while (true) { // Poll for RPCs rpcPollTimer.Start(); rpcPollTimeout.Reset(); rpcPollTimeout.Start(); while (true) { PollRequests(rpcYieldedContinuations); if (!config.BlockingRecv) { break; } if (rpcPollTimeout.ElapsedTicks > recvTimeoutTicks) { break; } if (rpcTimer.ElapsedTicks > maxTimePerUpdateTicks) { break; } if (rpcContinuations.Count > 0) { break; } } rpcPollTimer.Stop(); if (rpcContinuations.Count == 0) { break; } // Execute RPCs rpcExecTimer.Start(); for (int i = 0; i < rpcContinuations.Count; i++) { var continuation = rpcContinuations [i]; // Ignore the continuation if the client has disconnected if (!continuation.Client.Connected) { continue; } // Max exec time exceeded, delay to next update if (rpcTimer.ElapsedTicks > maxTimePerUpdateTicks) { rpcYieldedContinuations.Add(continuation); continue; } // Execute the continuation try { ExecuteContinuation(continuation); } catch (YieldException e) { rpcYieldedContinuations.Add((RequestContinuation)e.Continuation); } rpcsExecuted++; } rpcContinuations.Clear(); rpcExecTimer.Stop(); // Exit if only execute one RPC per update if (config.OneRPCPerUpdate) { break; } // Exit if max exec time exceeded if (rpcTimer.ElapsedTicks > maxTimePerUpdateTicks) { break; } } // Run yielded continuations on the next update var tmp = rpcContinuations; rpcContinuations = rpcYieldedContinuations; rpcYieldedContinuations = tmp; rpcTimer.Stop(); RPCsExecuted += rpcsExecuted; TimePerRPCUpdate = (float)rpcTimer.ElapsedSeconds(); PollTimePerRPCUpdate = (float)rpcPollTimer.ElapsedSeconds(); ExecTimePerRPCUpdate = (float)rpcExecTimer.ElapsedSeconds(); }
/// <summary> /// Update the RPC server, called once every FixedUpdate. /// This method receives and executes RPCs, for up to MaxTimePerUpdate microseconds. /// RPCs are delayed to the next update if this time expires. If AdaptiveRateControl /// is true, MaxTimePerUpdate will be automatically adjusted to achieve a target framerate. /// If NonBlockingUpdate is false, this call will block waiting for new RPCs for up to /// MaxPollTimePerUpdate microseconds. If NonBlockingUpdate is true, a single non-blocking call /// will be made to check for new RPCs. /// </summary> void RPCServerUpdate() { var timer = Stopwatch.StartNew(); var pollTimeout = new Stopwatch(); var pollTimer = new Stopwatch(); var execTimer = new Stopwatch(); long maxTimePerUpdateTicks = StopwatchExtensions.MicrosecondsToTicks(MaxTimePerUpdate); long recvTimeoutTicks = StopwatchExtensions.MicrosecondsToTicks(RecvTimeout); ulong rpcsExecuted = 0; var yieldedContinuations = new List <RequestContinuation> (); rpcServer.Update(); while (true) { // Poll for RPCs pollTimer.Start(); pollTimeout.Reset(); pollTimeout.Start(); while (true) { PollRequests(yieldedContinuations); if (!BlockingRecv) { break; } if (pollTimeout.ElapsedTicks > recvTimeoutTicks) { break; } if (timer.ElapsedTicks > maxTimePerUpdateTicks) { break; } if (continuations.Any()) { break; } } pollTimer.Stop(); if (!continuations.Any()) { break; } // Execute RPCs execTimer.Start(); foreach (var continuation in continuations) { // Ignore the continuation if the client has disconnected if (!continuation.Client.Connected) { continue; } // Max exec time exceeded, delay to next update if (timer.ElapsedTicks > maxTimePerUpdateTicks) { yieldedContinuations.Add(continuation); continue; } // Execute the continuation try { ExecuteContinuation(continuation); } catch (YieldException e) { yieldedContinuations.Add((RequestContinuation)e.Continuation); } rpcsExecuted++; } continuations.Clear(); execTimer.Stop(); // Exit if only execute one RPC per update if (OneRPCPerUpdate) { break; } // Exit if max exec time exceeded if (timer.ElapsedTicks > maxTimePerUpdateTicks) { break; } } // Run yielded continuations on the next update continuations = yieldedContinuations; timer.Stop(); RPCsExecuted += rpcsExecuted; TimePerRPCUpdate = (float)timer.ElapsedSeconds(); PollTimePerRPCUpdate = (float)pollTimer.ElapsedSeconds(); ExecTimePerRPCUpdate = (float)execTimer.ElapsedSeconds(); }
private static void RunAsserts(TimeSpan? maxAverage, TimeSpan? maxTotal, StopwatchExtensions.TimedExecutionSummary executionSummary, Func<TimeSpan?, string> format) { if(maxTotal.HasValue && executionSummary.Total > maxTotal.Value) { throw new Exception($"{nameof(maxTotal)}: {format(maxTotal)} exceeded. Was: {format(executionSummary.Total)}"); } if(maxAverage.HasValue && executionSummary.Average > maxAverage.Value) { throw new Exception($"{nameof(maxAverage)} exceeded"); } }
private Thread CreateDomainThread(int threadIndex) { System.Diagnostics.Debug.WriteLine("CreateDomainThread: " + threadIndex); var myPoolDomain = poolDomains[threadIndex]; var thread = new Thread(() => { Interlocked.Increment(ref numberOfThreadsInPool); // Here we enforce the "one domain, one thread" relationship try { var appDomain = AppDomainHelpers.CreateSandbox("Host Sandbox"); var manager = (SimpleHostAppDomainManager)appDomain.DomainManager; lock (poolLock) { myPoolDomain.domainId = appDomain.Id; } while (!snippetsQueue.IsCompleted) { defaultDomainManager.ResetContextFor(myPoolDomain); // And here is were we "rent" one AppDomain and use it to run a snippet SnippetInfo snippetToRun = null; try { snippetToRun = snippetsQueue.Take(); } catch (InvalidOperationException) { // Someone called "complete". No more snippets in this process. // We want to exit the pool. return; } if (snippetToRun != null) { System.Diagnostics.Debug.WriteLine("Starting snippet '" + snippetToRun.methodName + "' in domain " + myPoolDomain.domainId); SnippetResult result = new SnippetResult(); bool recycleDomain = false; try { Interlocked.Increment(ref myPoolDomain.numberOfUsages); // Record when we started long startTimestamp = StopwatchExtensions.GetTimestampMillis(); System.Diagnostics.Debug.WriteLine("Starting execution at " + startTimestamp); Thread.VolatileWrite(ref myPoolDomain.timeOfSubmission, startTimestamp); // Thread transitions into the AppDomain // This function DOES NOT throw result = manager.InternalRun(appDomain, snippetToRun.assemblyFile, snippetToRun.mainTypeName, snippetToRun.methodName, true); // ...back to the main AppDomain Debug.Assert(AppDomain.CurrentDomain.IsDefaultAppDomain()); long currentTime = StopwatchExtensions.GetTimestampMillis(); result.executionTime = currentTime - Thread.VolatileRead(ref myPoolDomain.timeOfSubmission); // Flag it as "not executing" Thread.VolatileWrite(ref myPoolDomain.timeOfSubmission, 0); } catch (ThreadAbortException ex) { // Someone called abort on us. result.exception = ex.Message; // It may be possible to use this domain again, otherwise we will recycle if (Object.Equals(ex.ExceptionState, timeoutAbortToken)) { // The abort was issued by us because we timed out System.Diagnostics.Debug.WriteLine("Thread Abort due to timeout"); result.status = SnippetStatus.Timeout; } else if (Object.Equals(ex.ExceptionState, threadsExaustedAbortToken)) { System.Diagnostics.Debug.WriteLine("Thread Abort due to thread exaustion"); result.status = SnippetStatus.ResourceError; } else { // If it wasn't us, give us time to record the result; we will recycle (unload) the domain System.Diagnostics.Debug.WriteLine("Thread Abort due to external factors"); result.status = SnippetStatus.CriticalError; recycleDomain = true; } // Give us time to record the result; if needed, we will recycle (unload) the domain later Thread.ResetAbort(); } catch (Exception ex) { result.exception = ex.Message; // Check if someone is misbehaving, throwing something else to "mask" the TAE if (Thread.CurrentThread.ThreadState == System.Threading.ThreadState.AbortRequested) { result.status = SnippetStatus.CriticalError; recycleDomain = true; // Give us time to record the result; we will recycle (unload) the domain Thread.ResetAbort(); } else { result.status = SnippetStatus.ExecutionError; } } // "Although C# only allows you to throw objects of type Exception and types deriving from it, // other languages don’t have any such restriction." // http://weblogs.asp.net/kennykerr/introduction-to-msil-part-5-exception-handling // It turns out this is no longer necessary // http://blogs.msdn.com/b/jmanning/archive/2005/09/16/469091.aspx // catch { } // No need to catch StackOverflowException; the Host will escalate to a (rude) domain unload // for us // TODO: check that AppDomain.DomainUnload is called anyway! // Before looping, check if we are OK; we reuse the domain only if we are not leaking int threadsInDomain = defaultDomainManager.GetThreadCount(appDomain.Id); int memoryUsage = defaultDomainManager.GetMemoryUsage(appDomain.Id); System.Diagnostics.Debug.WriteLine("============= AppDomain {0} =============", appDomain.Id); System.Diagnostics.Debug.WriteLine("Finished in: {0}", result.executionTime); System.Diagnostics.Debug.WriteLine("Status: {0}", result.status); if (result.exception != null) { System.Diagnostics.Debug.WriteLine("Exception: " + result.exception); } System.Diagnostics.Debug.WriteLine("Threads: {0}", threadsInDomain); System.Diagnostics.Debug.WriteLine("Memory: {0}", memoryUsage); System.Diagnostics.Debug.WriteLine("========================================"); if (threadsInDomain > 1) { // The snippet is leaking threads // Flag snippet as "leaking" result.status = SnippetStatus.CriticalError; System.Diagnostics.Debug.WriteLine("Leaking snippet"); recycleDomain = true; } else if (MaxReuse > 0 && myPoolDomain.numberOfUsages >= MaxReuse) { System.Diagnostics.Debug.WriteLine("Domain too old"); // Same if the domain is too old recycleDomain = true; } // Return the result to the caller if (!String.IsNullOrEmpty(snippetToRun.submissionId)) { var completion = submissionMap[snippetToRun.submissionId]; // TCS is thread-safe (can be called cross-thread) completion.TrySetResult(result); } if (recycleDomain) { System.Diagnostics.Debug.WriteLine("Recycling domain..."); RecycleDomain(threadIndex); } else { // Otherwise, ensure that what was allocated by the snippet is freed GC.Collect(); System.Diagnostics.Debug.WriteLine("MonitoringSurvivedMemorySize {0}", appDomain.MonitoringSurvivedMemorySize); System.Diagnostics.Debug.WriteLine("MonitoringTotalAllocatedMemorySize {0}", appDomain.MonitoringTotalAllocatedMemorySize); System.Diagnostics.Debug.WriteLine("MonitoringTotalProcessorTime {0}", appDomain.MonitoringTotalProcessorTime); } } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Exception caught:\n" + ex.ToString()); RecycleDomain(threadIndex); } }); thread.Name = "DomainPool thread " + threadIndex; myPoolDomain.mainThread = thread; thread.Priority = ThreadPriority.BelowNormal; return(thread); }
private static void PrintSummary (int iterations, TimeSpan? maxAverage, TimeSpan? maxTotal, string description, Func<TimeSpan?, string> format, StopwatchExtensions.TimedExecutionSummary executionSummary) { if(iterations > 1) { Console.WriteLine( $@"Executed {iterations:N} iterations of {description} Total: {format(executionSummary.Total)} Limit: {format(maxTotal)} Average: {format (executionSummary.Average)} Limit: {format(maxAverage)}"); } else { Console.WriteLine( $@"Executed {iterations} iterations of {description} Total: {format(executionSummary.Total)} Limit: {format(maxTotal)}"); } }
protected override void Update(GameTime gameTime) { Int64 now = Stopwatch.GetTimestamp(); // Allows the game to exit if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) { this.Exit(); } // // Update controls // KeyboardState keyboardState = Keyboard.GetState(); playerPositionControl.Update(keyboardState, ref playerPosition); // // Update Background Color // backgroundColor = new Color((Int32)((gameTime.TotalGameTime.Seconds * 100) & 0xFF), 100, 100); // // Create Center Translation Matrix // if (viewWidth != GraphicsDevice.Viewport.Width || viewHeightHalf != GraphicsDevice.Viewport.Height) { // Window size changed viewWidth = GraphicsDevice.Viewport.Width; viewWidthHalf = viewWidth / 2; viewHeight = GraphicsDevice.Viewport.Height; viewHeightHalf = viewHeight / 2; maxWidthOrHeight = (viewWidth >= viewHeight) ? viewWidth : viewHeight; maxWidthOrHeightHalf = maxWidthOrHeight / 2; windowCenterTranslationMatrix = Matrix.CreateTranslation(viewWidthHalf, viewHeightHalf, 0); } // // Update Game World rotation // //gameWorldRotationMatrix = gameWorldRotationMatrix * Matrix.CreateRotationZ((float)gameTime.ElapsedGameTime.Ticks * .00000001f); gameWorldMatrix = gameWorldRotationMatrix * windowCenterTranslationMatrix; // // Add new Update Obstacles // while (lastObstacleUpdateTime < now) { for (int i = 0; i < obstacles.Count; i++) { obstacleDistances[i] -= 1; } // // Check if first obstacle must be removed // if (obstacles.Count > 0 && obstacleDistances[0] <= 0) { obstacles.RemoveAt(0); obstacleDistances.RemoveAt(0); } // // Keep adding obstacles till distance is good // GenerateObstacles(); lastObstacleUpdateTime += StopwatchExtensions.MillisToStopwatchTicks(1); } }