public void EndBlock(string member, int line, string file, MyTimeSpan?customTime = null, float customValue = 0, string timeFormat = null, string valueFormat = null) { Debug.Assert(!EnableAsserts || OwnerThread == Thread.CurrentThread); if (m_levelSkipCount > 0) { m_levelSkipCount--; return; } if (m_currentProfilingStack.Count > 0) { MyProfilerBlock profilingBlock = m_currentProfilingStack.Pop(); CheckEndBlock(profilingBlock, member, file, GetParentId()); profilingBlock.CustomValue = customValue; profilingBlock.TimeFormat = timeFormat; profilingBlock.ValueFormat = valueFormat; profilingBlock.End(MemoryProfiling, customTime); } else { Debug.Fail(String.Format("Unpaired profiling end block encountered for '{0}'{1}File: {2}({3}){1}", member, Environment.NewLine, file, line)); } if (AutoCommit && m_currentProfilingStack.Count == 0) { CommitInternal(); } }
public void StartBlock(string name, string memberName, int line, string file) { Debug.Assert(!EnableAsserts || OwnerThread == Thread.CurrentThread); if (m_levelLimit != -1 && m_currentProfilingStack.Count >= m_levelLimit) { m_levelSkipCount++; return; } MyProfilerBlock profilingBlock = null; MyProfilerBlockKey key = new MyProfilerBlockKey(file, memberName, name, line, GetParentId()); if (!m_profilingBlocks.TryGetValue(key, out profilingBlock) && !m_blocksToAdd.TryGetValue(key, out profilingBlock)) { profilingBlock = new MyProfilerBlock(ref key, memberName, m_nextId++); if (m_currentProfilingStack.Count > 0) { profilingBlock.Parent = m_currentProfilingStack.Peek(); Debug.Assert(!profilingBlock.Parent.Children.Contains(profilingBlock), "Why is already between children?"); } m_blocksToAdd.Add(key, profilingBlock); } profilingBlock.Start(MemoryProfiling); m_currentProfilingStack.Push(profilingBlock); }
public void Init(MyProfilerBlockObjectBuilderInfo data) { Id = data.Id; Key = data.Key; Invalid = data.Invalid; TimeFormat = data.TimeFormat; ValueFormat = data.ValueFormat; CallFormat = data.CallFormat; ProcessMemory = data.ProcessMemory; ManagedMemoryBytes = data.ManagedMemoryBytes; Miliseconds = data.Miliseconds; CustomValues = data.CustomValues; NumCallsArray = data.NumCallsArray; Children = data.Children; Parent = data.Parent; }
void CheckEndBlock(MyProfilerBlock profilingBlock, string member, string file, int parentId) { if (EnableAsserts && !profilingBlock.Key.Member.Equals(member) || profilingBlock.Key.ParentId != parentId || profilingBlock.Key.File != file) { var trace = new StackTrace(2, true); for (int i = 0; i < trace.FrameCount; i++) { var frame = trace.GetFrame(i); if (frame.GetFileName() == profilingBlock.Key.File && frame.GetMethod().Name == member) { Debug.Fail(String.Format("Premature call to EndProfilingBlock in {0}({1}){2}", file, frame.GetFileLineNumber(), Environment.NewLine)); return; } } Debug.Fail(String.Format("Profiling end block missing for '{0}'{1}File: {2}({3}){1}", profilingBlock.Key.Name, Environment.NewLine, profilingBlock.Key.File, profilingBlock.Key.Line)); } }
public void StartBlock(string name, string memberName, int line, string file, int forceOrder = int.MaxValue) { Debug.Assert(!EnableAsserts || OwnerThread == Thread.CurrentThread); if (m_levelLimit != -1 && m_currentProfilingStack.Count >= m_levelLimit) { m_levelSkipCount++; return; } MyProfilerBlock profilingBlock = null; MyProfilerBlockKey key = new MyProfilerBlockKey(file, memberName, name, line, GetParentId()); if (!m_profilingBlocks.TryGetValue(key, out profilingBlock) && !m_blocksToAdd.TryGetValue(key, out profilingBlock)) { if (blockPool.Count == 0) { for (int i = 0; i < PROFILER_BLOCK_INCREMENT_STEP; i++) { blockPool.Add(new MyProfilerBlock()); } } profilingBlock = blockPool[0]; blockPool.RemoveAt(0); profilingBlock.SetBlockData(ref key, m_nextId++, forceOrder); if (m_currentProfilingStack.Count > 0) { profilingBlock.Parent = m_currentProfilingStack.Peek(); Debug.Assert(!profilingBlock.Parent.Children.Contains(profilingBlock), "Why is already between children?"); } m_blocksToAdd.Add(key, profilingBlock); } profilingBlock.Start(MemoryProfiling); m_currentProfilingStack.Push(profilingBlock); }
public static MyProfilerBlock FindBlockByMax(int frameIndex, int lastValidFrame) { if (!IsValidIndex(frameIndex, lastValidFrame)) { return(null); } float max = float.MinValue; MyProfilerBlock block = null; var children = m_selectedProfiler.SelectedRootChildren; for (int i = 0; i < children.Count; i++) { var profilerBlock = children[i]; float val = profilerBlock.Miliseconds[frameIndex]; if (val > max) { max = val; block = profilerBlock; } } return(block); }
public void EndBlock(string member, int line, string file, MyTimeSpan?customTime = null, float customValue = 0, string timeFormat = null, string valueFormat = null) { Debug.Assert(!EnableAsserts || OwnerThread == Thread.CurrentThread); if (m_levelSkipCount > 0) { m_levelSkipCount--; return; } MyProfilerBlock profilingBlock = m_currentProfilingStack.Pop(); CheckEndBlock(profilingBlock, member, file, GetParentId()); profilingBlock.CustomValue = customValue; profilingBlock.TimeFormat = timeFormat; profilingBlock.ValueFormat = valueFormat; profilingBlock.End(MemoryProfiling, customTime); if (AutoCommit && m_currentProfilingStack.Count == 0) { CommitInternal(); } }
public static void HandleInput(RenderProfilerCommand command, int index) { switch (command) { case RenderProfilerCommand.Enable: { if (!m_enabled) { m_enabled = true; m_profilerProcessingEnabled = true; // Enable when disabled and keep enabled SetLevel(); } break; } case RenderProfilerCommand.ToggleEnabled: { // Enable or Disable profiler drawing if (m_enabled) { m_enabled = false; m_useCustomFrame = false; } else { m_enabled = true; m_profilerProcessingEnabled = true; // Enable when disabled and keep enabled } break; } case RenderProfilerCommand.JumpToRoot: m_selectedProfiler.SelectedRoot = null; break; case RenderProfilerCommand.JumpToLevel: { // Enable when disabled, added this for programmers who are too used to using the numpad 0 to open the profiler. if (index == 0 && !m_enabled) { m_enabled = true; m_profilerProcessingEnabled = true; // Enable when disabled and keep enabled } else { m_selectedProfiler.SelectedRoot = FindBlockByIndex(index - 1); // On screen it's indexed from 1 (zero is level up) } break; } case RenderProfilerCommand.Pause: { Paused = !Paused; GpuProfiler.AutoCommit = !Paused; break; } case RenderProfilerCommand.NextThread: { lock (m_threadProfilers) { int profilerIndex = (m_threadProfilers.IndexOf(m_selectedProfiler) + 1) % m_threadProfilers.Count; m_selectedProfiler = m_threadProfilers[profilerIndex]; } break; } case RenderProfilerCommand.PreviousThread: { lock (m_threadProfilers) { int profilerIndex = (m_threadProfilers.IndexOf(m_selectedProfiler) - 1 + m_threadProfilers.Count) % m_threadProfilers.Count; m_selectedProfiler = m_threadProfilers[profilerIndex]; } break; } case RenderProfilerCommand.Reset: { lock (m_threadProfilers) { foreach (var profiler in m_threadProfilers) { profiler.Reset(); } m_selectedFrame = 0; } break; } case RenderProfilerCommand.NextFrame: { MyRenderProfiler.NextFrame(index); break; } case RenderProfilerCommand.PreviousFrame: { MyRenderProfiler.PreviousFrame(index); break; } case RenderProfilerCommand.DisableFrameSelection: { m_useCustomFrame = false; break; } case RenderProfilerCommand.IncreaseLevel: { m_levelLimit++; SetLevel(); break; } case RenderProfilerCommand.DecreaseLevel: { m_levelLimit--; if (m_levelLimit < -1) { m_levelLimit = -1; } SetLevel(); break; } case RenderProfilerCommand.CopyPathToClipboard: { StringBuilder pathBuilder = new StringBuilder(200); MyProfilerBlock currentBlock = m_selectedProfiler.SelectedRoot; while (currentBlock != null) { if (pathBuilder.Length > 0) { pathBuilder.Insert(0, " > "); } pathBuilder.Insert(0, currentBlock.Name); currentBlock = currentBlock.Parent; } if (pathBuilder.Length > 0) { // Clipboard can only be accessed from a thread on the STA apartment System.Threading.Thread thread = new System.Threading.Thread(() => System.Windows.Forms.Clipboard.SetText(pathBuilder.ToString())); thread.SetApartmentState(System.Threading.ApartmentState.STA); thread.Start(); thread.Join(); } break; } case RenderProfilerCommand.TryGoToPathInClipboard: { string fullPath = string.Empty; Exception threadEx = null; System.Threading.Thread staThread = new System.Threading.Thread( delegate() { try { fullPath = System.Windows.Forms.Clipboard.GetText(); } catch (Exception ex) { threadEx = ex; } }); staThread.SetApartmentState(System.Threading.ApartmentState.STA); staThread.Start(); staThread.Join(); if (!string.IsNullOrEmpty(fullPath)) { string[] split = fullPath.Split(new string[] { " > " }, StringSplitOptions.None); MyProfilerBlock pathBlock = null; List <MyProfilerBlock> blockSet = m_selectedProfiler.RootBlocks; for (int i = 0; i < split.Length; i++) { string blockName = split[i]; MyProfilerBlock oldPath = pathBlock; for (int j = 0; j < blockSet.Count; j++) { MyProfilerBlock block = blockSet[j]; if (block.Name == blockName) { pathBlock = block; blockSet = pathBlock.Children; break; } } // If the path did not change, we cannot go any deeper, break out of this loop if (oldPath == pathBlock) { break; } } if (pathBlock != null) { m_selectedProfiler.SelectedRoot = pathBlock; } } break; } case RenderProfilerCommand.SetLevel: { m_levelLimit = index; if (m_levelLimit < -1) { m_levelLimit = -1; } SetLevel(); break; } case RenderProfilerCommand.DecreaseLocalArea: m_frameLocalArea = Math.Max(2, m_frameLocalArea / 2); break; case RenderProfilerCommand.IncreaseLocalArea: m_frameLocalArea = Math.Min(MyProfiler.MAX_FRAMES, m_frameLocalArea * 2); break; case RenderProfilerCommand.IncreaseRange: m_milisecondsGraphScale.IncreaseYRange(); break; case RenderProfilerCommand.DecreaseRange: m_milisecondsGraphScale.DecreaseYRange(); break; case RenderProfilerCommand.ChangeSortingOrder: m_sortingOrder += 1; if (m_sortingOrder >= RenderProfilerSortingOrder.NumSortingTypes) { m_sortingOrder = RenderProfilerSortingOrder.Id; } break; default: System.Diagnostics.Debug.Assert(false, "Unknown command"); break; } }
static MyRenderProfiler() { m_levelLimit = VRage.MyCompilationSymbols.ProfileFromStart ? -1 : 0; // Create block, some unique id m_fpsBlock = MyProfiler.CreateExternalBlock("FPS", -2); }
private void CommitInternal() { Debug.Assert(!EnableAsserts || OwnerThread == Thread.CurrentThread); Debug.Assert(m_currentProfilingStack.Count == 0, "CommitFrame cannot be called when there are some opened blocks, it must be outside blocks!"); m_currentProfilingStack.Clear(); if (m_blocksToAdd.Count > 0) { using (m_historyLock.AcquireExclusiveUsing()) { foreach (var block in m_blocksToAdd) { if (block.Value.Parent != null) { block.Value.Parent.Children.AddOrInsert(block.Value, block.Value.ForceOrder); } else { m_rootBlocks.AddOrInsert(block.Value, block.Value.ForceOrder); } m_profilingBlocks.Add(block.Key, block.Value); } m_blocksToAdd.Clear(); Interlocked.Exchange(ref m_remainingWindow, UPDATE_WINDOW - 1); // We have lock, no one is in draw, reset window } } else if (m_historyLock.TryAcquireExclusive()) { Interlocked.Exchange(ref m_remainingWindow, UPDATE_WINDOW - 1); // We have lock, no one is in draw, reset window m_historyLock.ReleaseExclusive(); } else if (Interlocked.Decrement(ref m_remainingWindow) < 0) { // Window is empty, wait for lock and reset it using (m_historyLock.AcquireExclusiveUsing()) { Interlocked.Exchange(ref m_remainingWindow, UPDATE_WINDOW - 1); // We have lock, no one is in draw, reset window } } int callCount = 0; m_levelLimit = m_newLevelLimit; int writeFrame = (m_lastFrameIndex + 1) % MyProfiler.MAX_FRAMES; foreach (MyProfilerBlock profilerBlock in m_profilingBlocks.Values) { callCount += profilerBlock.NumCalls; profilerBlock.ManagedMemoryBytes[writeFrame] = profilerBlock.DeltaManagedB; if (MemoryProfiling) { profilerBlock.ProcessMemory[writeFrame] = profilerBlock.ProcessDeltaMB; } profilerBlock.NumCallsArray[writeFrame] = profilerBlock.NumCalls; profilerBlock.CustomValues[writeFrame] = profilerBlock.CustomValue; profilerBlock.Miliseconds[writeFrame] = (float)profilerBlock.Elapsed.Miliseconds; // Unused profilerBlock.averageMiliseconds = 0.9f * profilerBlock.averageMiliseconds + 0.1f * (float)profilerBlock.Elapsed.Miliseconds; //profilerBlock.NumChildCalls = profilerBlock.GetNumChildCalls(); if (ENABLE_PROFILER_LOG) { if (profilerBlock.Elapsed.Miliseconds > LOG_THRESHOLD_MS) { m_logWriter.Write(DateTime.Now.ToString()); m_logWriter.Write("; "); m_logWriter.Write(((int)profilerBlock.Elapsed.Miliseconds).ToString()); m_logWriter.Write("; "); m_logWriter.Write(profilerBlock.Name); MyProfilerBlock tempBlock = profilerBlock; while (tempBlock.Parent != null) { tempBlock = tempBlock.Parent; m_logWriter.Write(" <- " + tempBlock.Name); } m_logWriter.WriteLine(""); } } profilerBlock.Clear(); } TotalCalls[writeFrame] = callCount; m_lastFrameIndex = writeFrame; }