/// <summary> /// Verify the profiler service XEvent session factory /// </summary> //[Fact] public void TestCreateXEventSession() { var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master"); ProfilerService profilerService = new ProfilerService(); IXEventSession xeSession = profilerService.CreateXEventSession(liveConnection.ConnectionInfo); Assert.NotNull(xeSession); Assert.NotNull(xeSession.GetTargetXml()); }
public ChunkManager(Alex alex, GraphicsDevice graphics, AlexOptions option, IWorld world) { Game = alex; Graphics = graphics; World = world; Options = option; ProfilerService = alex.Services.GetService <ProfilerService>(); Chunks = new ConcurrentDictionary <ChunkCoordinates, IChunkColumn>(); var fogStart = 0; TransparentEffect = new AlphaTestEffect(Graphics) { Texture = alex.Resources.Atlas.GetStillAtlas(), VertexColorEnabled = true, World = Matrix.Identity, AlphaFunction = CompareFunction.Greater, ReferenceAlpha = 127, FogStart = fogStart, FogEnabled = false }; AnimatedEffect = new AlphaTestEffect(Graphics) { Texture = alex.Resources.Atlas.GetAtlas(0), VertexColorEnabled = true, World = Matrix.Identity, AlphaFunction = CompareFunction.Greater, ReferenceAlpha = 127, FogStart = fogStart, FogEnabled = false }; OpaqueEffect = new BasicEffect(Graphics) { TextureEnabled = true, Texture = alex.Resources.Atlas.GetStillAtlas(), FogStart = fogStart, VertexColorEnabled = true, LightingEnabled = true, FogEnabled = false }; //if (alex.) FrameCount = alex.Resources.Atlas.GetFrameCount(); ChunkManagementThread = new Thread(ChunkUpdateThread) { IsBackground = true, Name = "Chunk Management" }; HighestPriority = new ConcurrentQueue <ChunkCoordinates>(); }
public MainWindowViewModel( StoryService storyService, GameScriptService gameScriptService, ProfilerService profilerService, ScreenViewModel screenViewModel, ProfilerViewModel profilerViewModel, GameInfoDialogViewModel gameInfoDialogViewModel, GameScriptDialogViewModel gameScriptDialogViewModel) : base("MainWindowView") { this.storyService = storyService; this.storyService.StoryOpened += StoryService_StoryOpened; this.storyService.StoryClosing += StoryService_StoryClosing; this.gameScriptService = gameScriptService; this.profilerService = profilerService; this.screenViewModel = screenViewModel; this.profilerViewModel = profilerViewModel; this.gameInfoDialogViewModel = gameInfoDialogViewModel; this.gameScriptDialogViewModel = gameScriptDialogViewModel; this.OpenStoryCommand = RegisterCommand( text: "Open", name: "Open", executed: OpenStoryExecuted, canExecute: OpenStoryCanExecute, inputGestures: new KeyGesture(Key.O, ModifierKeys.Control)); this.EditGameScriptCommand = RegisterCommand( text: "EditGameScript", name: "Edit Game Script", executed: EditGameScriptExecuted, canExecute: EditGameScriptCanExecute); this.ExitCommand = RegisterCommand( text: "Exit", name: "Exit", executed: ExitExecuted, canExecute: ExitCanExecute, inputGestures: new KeyGesture(Key.F4, ModifierKeys.Alt)); this.StopCommand = RegisterCommand( text: "Stop", name: "Stop", executed: StopExecuted, canExecute: StopCanExecute); this.AboutGameCommand = RegisterCommand( text: "AboutGame", name: "About Game", executed: AboutGameExecuted, canExecute: AboutGameCanExecute); }
public ProfilerViewModel( ProfilerService profilerService, StoryService storyService) : base("ProfilerView") { this.profilerService = profilerService; this.storyService = storyService; this.profilerService.Starting += ProfilerService_Starting; this.profilerService.Stopped += ProfilerService_Stopped; }
public async Task TestStopProfilingRequest() { bool success = false; bool stopped = false; string testUri = "test_session"; // capture stopping results var requestContext = new Mock <RequestContext <StopProfilingResult> >(); requestContext.Setup(rc => rc.SendResult(It.IsAny <StopProfilingResult>())) .Returns <StopProfilingResult>((result) => { success = true; return(Task.FromResult(0)); }); // capture if session was stopped var mockSession = new Mock <IXEventSession>(); mockSession.Setup(p => p.Stop()).Callback(() => { stopped = true; }); var sessionListener = new TestSessionListener(); var profilerService = new ProfilerService(); profilerService.SessionMonitor.AddSessionListener(sessionListener); profilerService.ConnectionServiceInstance = TestObjects.GetTestConnectionService(); ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo(); profilerService.ConnectionServiceInstance.OwnerToConnectionMap.Add(testUri, connectionInfo); profilerService.XEventSessionFactory = new TestXEventSessionFactory(); var requestParams = new StopProfilingParams(); requestParams.OwnerUri = testUri; profilerService.SessionMonitor.StartMonitoringSession(testUri, mockSession.Object); await profilerService.HandleStopProfilingRequest(requestParams, requestContext.Object); requestContext.VerifyAll(); // check that session was succesfully stopped and stop was called Assert.True(success); Assert.True(stopped); // should not be able to remove the session, it should already be gone ProfilerSession ps; Assert.False(profilerService.SessionMonitor.StopMonitoringSession(testUri, out ps)); }
protected override void OnCreate(Bundle savedInstanceState) { ProfilerService.RegisterInternalEvent("MainActivity OnCreate Init"); TabLayoutResource = Resource.Layout.Tabbar; ToolbarResource = Resource.Layout.Toolbar; base.OnCreate(savedInstanceState); Forms.SetFlags("FastRenderers_Experimental"); Forms.Init(this, savedInstanceState); DependencyService.Register <ProfilerService>(); LoadApplication(new App()); ProfilerService.RegisterInternalEvent("MainActivity OnCreate End"); }
public async Task TestStoppedSessionNotification() { bool sessionStopped = false; string testUri = "profiler_uri"; // capture listener event notifications var mockSession = new Mock <IXEventSession>(); mockSession.Setup(p => p.GetTargetXml()).Callback(() => { throw new XEventException(); }); var mockListener = new Mock <IProfilerSessionListener>(); mockListener.Setup(p => p.SessionStopped(It.IsAny <string>(), It.IsAny <int>())).Callback(() => { sessionStopped = true; }); var profilerService = new ProfilerService(); profilerService.SessionMonitor.AddSessionListener(mockListener.Object); profilerService.ConnectionServiceInstance = TestObjects.GetTestConnectionService(); ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo(); profilerService.ConnectionServiceInstance.OwnerToConnectionMap.Add(testUri, connectionInfo); // start monitoring test session profilerService.SessionMonitor.StartMonitoringSession(testUri, mockSession.Object); // wait for polling to finish, or for timeout System.Timers.Timer pollingTimer = new System.Timers.Timer(); pollingTimer.Interval = 10000; pollingTimer.Start(); bool timeout = false; pollingTimer.Elapsed += new System.Timers.ElapsedEventHandler((s_, e_) => { timeout = true; }); while (sessionStopped == false && !timeout) { Thread.Sleep(250); } pollingTimer.Stop(); // check that a stopped session notification was sent Assert.True(sessionStopped); }
/// <summary> /// Verify that a start profiling request starts a profiling session /// </summary> //[Fact] public async Task TestHandleStartAndStopProfilingRequests() { using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile()) { var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath); ProfilerService profilerService = new ProfilerService(); // start a new session var startParams = new StartProfilingParams(); startParams.OwnerUri = connectionResult.ConnectionInfo.OwnerUri; startParams.TemplateName = "Standard"; string sessionId = null; var startContext = new Mock <RequestContext <StartProfilingResult> >(); startContext.Setup(rc => rc.SendResult(It.IsAny <StartProfilingResult>())) .Returns <StartProfilingResult>((result) => { // capture the session id for sending the stop message sessionId = result.SessionId; return(Task.FromResult(0)); }); await profilerService.HandleStartProfilingRequest(startParams, startContext.Object); startContext.VerifyAll(); // wait a bit for the session monitoring to initialize Thread.Sleep(TimeSpan.FromHours(1)); // stop the session var stopParams = new StopProfilingParams() { OwnerUri = sessionId }; var stopContext = new Mock <RequestContext <StopProfilingResult> >(); stopContext.Setup(rc => rc.SendResult(It.IsAny <StopProfilingResult>())) .Returns(Task.FromResult(0)); await profilerService.HandleStopProfilingRequest(stopParams, stopContext.Object); stopContext.VerifyAll(); } }
private void ConfigureServices() { XBLMSAService msa; var storage = new StorageSystem(LaunchSettings.WorkDir); ProfileManager = new ProfileManager(this, storage); Services.AddService <IStorageSystem>(storage); var optionsProvider = new OptionsProvider(storage); //optionsProvider.Load(); optionsProvider.AlexOptions.VideoOptions.UseVsync.Bind((value, newValue) => { SetVSync(newValue); }); if (optionsProvider.AlexOptions.VideoOptions.UseVsync.Value) { SetVSync(true); } optionsProvider.AlexOptions.VideoOptions.Fullscreen.Bind((value, newValue) => { SetFullscreen(newValue); }); if (optionsProvider.AlexOptions.VideoOptions.Fullscreen.Value) { SetFullscreen(true); } Services.AddService <IOptionsProvider>(optionsProvider); Services.AddService <IListStorageProvider <SavedServerEntry> >(new SavedServerDataProvider(storage)); Services.AddService(msa = new XBLMSAService()); Services.AddService <IServerQueryProvider>(new ServerQueryProvider(this)); Services.AddService <IPlayerProfileService>(ProfileService = new PlayerProfileService(msa, ProfileManager)); var profilingService = new ProfilerService(); Services.AddService <ProfilerService>(profilingService); Storage = storage; }
/// <summary> /// Test starting a profiling session and receiving event callback /// </summary> /// <returns></returns> // TODO: Fix flaky test. See https://github.com/Microsoft/sqltoolsservice/issues/459 //[Fact] public async Task TestStartProfilingRequest() { string sessionId = null; string testUri = "profiler_uri"; var requestContext = new Mock <RequestContext <StartProfilingResult> >(); requestContext.Setup(rc => rc.SendResult(It.IsAny <StartProfilingResult>())) .Returns <StartProfilingResult>((result) => { // capture the session id for sending the stop message sessionId = result.SessionId; return(Task.FromResult(0)); }); var sessionListener = new TestSessionListener(); var profilerService = new ProfilerService(); profilerService.SessionMonitor.AddSessionListener(sessionListener); profilerService.ConnectionServiceInstance = TestObjects.GetTestConnectionService(); ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo(); profilerService.ConnectionServiceInstance.OwnerToConnectionMap.Add(testUri, connectionInfo); profilerService.XEventSessionFactory = new TestXEventSessionFactory(); var requestParams = new StartProfilingParams(); requestParams.OwnerUri = testUri; requestParams.TemplateName = "Standard"; await profilerService.HandleStartProfilingRequest(requestParams, requestContext.Object); // wait a bit for profile sessions to be polled Thread.Sleep(500); requestContext.VerifyAll(); Assert.Equal(sessionListener.PreviousSessionId, sessionId); Assert.Equal(sessionListener.PreviousEvents.Count, 1); }
/// <summary> /// Test starting a profiling session and receiving event callback /// </summary> /// <returns></returns> // TODO: Fix flaky test. See https://github.com/Microsoft/sqltoolsservice/issues/459 //[Fact] public async Task TestStartProfilingRequest() { string sessionId = null; bool recievedEvents = false; string testUri = "profiler_uri"; var requestContext = new Mock <RequestContext <StartProfilingResult> >(); requestContext.Setup(rc => rc.SendResult(It.IsAny <StartProfilingResult>())) .Returns <StartProfilingResult>((result) => { // capture the session id for sending the stop message sessionId = result.SessionId; return(Task.FromResult(0)); }); // capture listener event notifications var mockListener = new Mock <IProfilerSessionListener>(); mockListener.Setup(p => p.EventsAvailable(It.IsAny <string>(), It.IsAny <List <ProfilerEvent> >(), It.IsAny <bool>())).Callback(() => { recievedEvents = true; }); var profilerService = new ProfilerService(); profilerService.SessionMonitor.AddSessionListener(mockListener.Object); profilerService.ConnectionServiceInstance = TestObjects.GetTestConnectionService(); ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo(); profilerService.ConnectionServiceInstance.OwnerToConnectionMap.Add(testUri, connectionInfo); profilerService.XEventSessionFactory = new TestXEventSessionFactory(); var requestParams = new StartProfilingParams(); requestParams.OwnerUri = testUri; requestParams.TemplateName = "Standard"; // start profiling session await profilerService.HandleStartProfilingRequest(requestParams, requestContext.Object); profilerService.SessionMonitor.PollSession(1); // simulate a short polling delay Thread.Sleep(200); profilerService.SessionMonitor.PollSession(1); // wait for polling to finish, or for timeout System.Timers.Timer pollingTimer = new System.Timers.Timer(); pollingTimer.Interval = 10000; pollingTimer.Start(); bool timeout = false; pollingTimer.Elapsed += new System.Timers.ElapsedEventHandler((s_, e_) => { timeout = true; }); while (sessionId == null && !timeout) { Thread.Sleep(250); } pollingTimer.Stop(); requestContext.VerifyAll(); // Check that the correct XEvent session was started Assert.Equal(sessionId, "1"); // check that the proper owner Uri was used Assert.True(recievedEvents); }
public async Task TestPauseProfilingRequest() { bool success = false; string testUri = "test_session"; bool recievedEvents = false; // capture pausing results var requestContext = new Mock <RequestContext <PauseProfilingResult> >(); requestContext.Setup(rc => rc.SendResult(It.IsAny <PauseProfilingResult>())) .Returns <PauseProfilingResult>((result) => { success = true; return(Task.FromResult(0)); }); // capture listener event notifications var mockListener = new Mock <IProfilerSessionListener>(); mockListener.Setup(p => p.EventsAvailable(It.IsAny <string>(), It.IsAny <List <ProfilerEvent> >(), It.IsAny <bool>())).Callback(() => { recievedEvents = true; }); // setup profiler service var profilerService = new ProfilerService(); profilerService.SessionMonitor.AddSessionListener(mockListener.Object); profilerService.ConnectionServiceInstance = TestObjects.GetTestConnectionService(); ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo(); profilerService.ConnectionServiceInstance.OwnerToConnectionMap.Add(testUri, connectionInfo); var requestParams = new PauseProfilingParams(); requestParams.OwnerUri = testUri; // begin monitoring session profilerService.SessionMonitor.StartMonitoringSession(testUri, new TestXEventSession1()); // poll the session profilerService.SessionMonitor.PollSession(1); Thread.Sleep(500); profilerService.SessionMonitor.PollSession(1); // wait for polling to finish, or for timeout System.Timers.Timer pollingTimer = new System.Timers.Timer(); pollingTimer.Interval = 10000; pollingTimer.Start(); bool timeout = false; pollingTimer.Elapsed += new System.Timers.ElapsedEventHandler((s_, e_) => { timeout = true; }); while (!recievedEvents && !timeout) { Thread.Sleep(250); } pollingTimer.Stop(); // confirm that polling works Assert.True(recievedEvents); // pause viewer await profilerService.HandlePauseProfilingRequest(requestParams, requestContext.Object); Assert.True(success); recievedEvents = false; success = false; profilerService.SessionMonitor.PollSession(1); // confirm that no events were sent to paused listener Assert.False(recievedEvents); // unpause viewer await profilerService.HandlePauseProfilingRequest(requestParams, requestContext.Object); Assert.True(success); profilerService.SessionMonitor.PollSession(1); // wait for polling to finish, or for timeout timeout = false; pollingTimer.Start(); while (!recievedEvents && !timeout) { Thread.Sleep(250); } // check that events got sent to listener Assert.True(recievedEvents); requestContext.VerifyAll(); }
static void Main(string[] args) { LoggerProvider lp = new LoggerProvider(); var solution = @"EPPlus.sln"; CSharpRecognitionContext ctx = new CSharpRecognitionContext("EPPlus"); ProfilerService.Init(typeof(NullProfiler), (s, t) => { }); using (ProfilerService.Current.Section("Total")) { using (ProfilerService.Current.Section("GetCompilations")) { ctx.Compilations = CSharpModelBuilder.GetRecognitionContextInputFromSolution(solution); } using (ProfilerService.Current.Section("Init")) { ctx.Init(lp); } SingletonRecognizer srec = new SingletonRecognizer(); srec.Context = ctx; CompositeRecognizer crec = new CompositeRecognizer(); crec.Context = ctx; //ProxyRecognizer prec = new ProxyRecognizer(); //prec.Context = ctx; ChainOfResponsiblityRecognizer correc = new ChainOfResponsiblityRecognizer(); correc.Context = ctx; FactoryMethodRecognizer frec = new FactoryMethodRecognizer(); frec.Context = ctx; DecoratorRecognizer drec = new DecoratorRecognizer(); drec.Context = ctx; MediatorRecognizer mmrec = new MediatorRecognizer(); mmrec.Context = ctx; Console.Clear(); using (var fres = File.CreateText("results.txt")) { foreach (var item in ctx.Types) { try { if (mmrec.IsInstance(item)) { Console.WriteLine("{0} is a mediator base", item.ToString()); fres.WriteLine(string.Format("{0} is a singleton", item.ToString())); } } catch { } try { if (srec.IsInstance(item)) { Console.WriteLine(string.Format("{0} is a singleton", item.ToString())); fres.WriteLine(string.Format("{0} is a singleton", item.ToString())); } } catch (Exception) { } try { if (crec.IsInstance(item)) { Console.WriteLine(string.Format("{0} is a composite", item.ToString())); fres.WriteLine(string.Format("{0} is a composite", item.ToString())); } } catch (Exception) { } //if (prec.isinstance(item)) //{ // console.writeline(string.format("{0} is a proxy", item.tostring())); // fres.writeline(string.format("{0} is a proxy", item.tostring())); //} try { if (correc.IsInstance(item)) { Console.WriteLine(string.Format("{0} is a chain of responsiblity base", item.ToString())); fres.WriteLine(string.Format("{0} is a chain of responsiblity base", item.ToString())); } } catch (Exception) { } try { if (drec.IsInstance(item)) { Console.WriteLine(string.Format("{0} is a decorator", item.ToString())); fres.WriteLine(string.Format("{0} is a decorator", item.ToString())); } } catch (Exception) { } } foreach (var item in ctx.Types.SelectMany(t => t.Methods)) { try { if (frec.IsInstance(item)) { Console.WriteLine(string.Format("{0} is a factory method", item.ToString())); fres.WriteLine(string.Format("{0} is a factory method", item.ToString())); } } catch (Exception) { } } } } Console.ReadLine(); }
internal bool UpdateChunk(ChunkCoordinates coordinates, IChunkColumn c) { var chunk = c as ChunkColumn; if (!Monitor.TryEnter(chunk.UpdateLock)) { Interlocked.Decrement(ref _chunkUpdates); return(false); //Another thread is already updating this chunk, return. } var scheduleType = chunk.Scheduled; var profiler = MiniProfiler.StartNew("chunk.update"); ChunkData data = null; bool force = !_chunkData.TryGetValue(coordinates, out data); try { //chunk.UpdateChunk(Graphics, World); var currentChunkY = Math.Min(((int)Math.Round(_cameraPosition.Y)) >> 4, (chunk.GetHeighest() >> 4) - 2); if (currentChunkY < 0) { currentChunkY = 0; } List <ChunkMesh> meshes = new List <ChunkMesh>(); using (profiler.Step("chunk.sections")) { for (var i = chunk.Sections.Length - 1; i >= 0; i--) { if (i < 0) { break; } var section = chunk.Sections[i] as ChunkSection; if (section == null || section.IsEmpty()) { continue; } if (i != currentChunkY && i != 0) { using (profiler.Step("chunk.neighboring")) { if (i > 0 && i < chunk.Sections.Length - 1) { var neighbors = chunk.CheckNeighbors(section, i, World).ToArray(); if (!section.HasAirPockets && neighbors.Length == 6) //All surrounded by solid. { // Log.Info($"Found section with solid neigbors, skipping."); continue; } if (i < currentChunkY && neighbors.Length >= 6) { continue; } } else if (i < currentChunkY) { continue; } } } //if (i == 0) force = true; if (force || !section.ScheduledUpdates.IsZero || section.IsDirty) { using (profiler.Step("chunk.meshing")) { var sectionMesh = GenerateSectionMesh(World, scheduleType, new Vector3(chunk.X * 16f, 0, chunk.Z * 16f), ref section, i); meshes.Add(sectionMesh); } } } } List <VertexPositionNormalTextureColor> vertices = new List <VertexPositionNormalTextureColor>(); List <int> transparentIndexes = new List <int>(); List <int> solidIndexes = new List <int>(); List <int> animatedIndexes = new List <int>(); foreach (var mesh in meshes) { var startVerticeIndex = vertices.Count; vertices.AddRange(mesh.Vertices); solidIndexes.AddRange(mesh.SolidIndexes.Select(a => startVerticeIndex + a)); transparentIndexes.AddRange(mesh.TransparentIndexes.Select(a => startVerticeIndex + a)); animatedIndexes.AddRange(mesh.AnimatedIndexes.Select(a => startVerticeIndex + a)); } if (vertices.Count > 0) { ProfilerService.ReportCount("chunk.vertexCount", vertices.Count); using (profiler.Step("chunk.buffer")) { var vertexArray = vertices.ToArray(); var solidArray = solidIndexes.ToArray(); var transparentArray = transparentIndexes.ToArray(); var animatedArray = animatedIndexes.ToArray(); if (data == null) { data = new ChunkData() { Buffer = GpuResourceManager.GetBuffer(this, Graphics, VertexPositionNormalTextureColor.VertexDeclaration, vertexArray.Length, BufferUsage.WriteOnly), SolidIndexBuffer = GpuResourceManager.GetIndexBuffer(this, Graphics, IndexElementSize.ThirtyTwoBits, solidArray.Length, BufferUsage.WriteOnly), TransparentIndexBuffer = GpuResourceManager.GetIndexBuffer(this, Graphics, IndexElementSize.ThirtyTwoBits, transparentArray.Length, BufferUsage.WriteOnly), AnimatedIndexBuffer = GpuResourceManager.GetIndexBuffer(this, Graphics, IndexElementSize.ThirtyTwoBits, animatedArray.Length, BufferUsage.WriteOnly) }; } PooledVertexBuffer oldBuffer = data.Buffer; PooledVertexBuffer newVertexBuffer = null; PooledIndexBuffer newsolidIndexBuffer = null; PooledIndexBuffer newTransparentIndexBuffer = null; PooledIndexBuffer newAnimatedIndexBuffer = null; PooledIndexBuffer oldAnimatedIndexBuffer = data.AnimatedIndexBuffer; PooledIndexBuffer oldSolidIndexBuffer = data.SolidIndexBuffer; PooledIndexBuffer oldTransparentIndexBuffer = data.TransparentIndexBuffer; using (profiler.Step("chunk.buffer.check")) if (vertexArray.Length >= data.Buffer.VertexCount) { // var oldBuffer = data.Buffer; PooledVertexBuffer newBuffer = GpuResourceManager.GetBuffer(this, Graphics, VertexPositionNormalTextureColor.VertexDeclaration, vertexArray.Length, BufferUsage.WriteOnly); newBuffer.SetData(vertexArray); newVertexBuffer = newBuffer; // data.Buffer = newBuffer; // oldBuffer?.Dispose(); ProfilerService.ReportCount("chunk.bufferSize", data.Buffer.MemoryUsage); ProfilerService.TriggerCounter("chunk.bufferResize"); } else { data.Buffer.SetData(vertexArray); ProfilerService.ReportCount("chunk.bufferSize", data.Buffer.MemoryUsage); } using (profiler.Step("Chunk Solid indexbuffer check")) if (solidArray.Length > data.SolidIndexBuffer.IndexCount) { // var old = data.SolidIndexBuffer; var newSolidBuffer = GpuResourceManager.GetIndexBuffer(this, Graphics, IndexElementSize.ThirtyTwoBits, solidArray.Length, BufferUsage.WriteOnly); newSolidBuffer.SetData(solidArray); newsolidIndexBuffer = newSolidBuffer; // data.SolidIndexBuffer = newSolidBuffer; // old?.Dispose(); } else { data.SolidIndexBuffer.SetData(solidArray); } using (profiler.Step("Chunk Transparent indexbuffer check")) if (transparentArray.Length > data.TransparentIndexBuffer.IndexCount) { // var old = data.TransparentIndexBuffer; var newTransparentBuffer = GpuResourceManager.GetIndexBuffer(this, Graphics, IndexElementSize.ThirtyTwoBits, transparentArray.Length, BufferUsage.WriteOnly); newTransparentBuffer.SetData(transparentArray); newTransparentIndexBuffer = newTransparentBuffer; } else { data.TransparentIndexBuffer.SetData(transparentArray); } using (profiler.Step("Chunk Animated indexbuffer check")) if (animatedArray.Length > data.AnimatedIndexBuffer.IndexCount) { // var old = data.TransparentIndexBuffer; var newTransparentBuffer = GpuResourceManager.GetIndexBuffer(this, Graphics, IndexElementSize.ThirtyTwoBits, animatedArray.Length, BufferUsage.WriteOnly); newTransparentBuffer.SetData(animatedArray); newAnimatedIndexBuffer = newTransparentBuffer; } else { data.AnimatedIndexBuffer.SetData(animatedArray); } using (profiler.Step("chunk.buffer.dispose")) { if (newVertexBuffer != null) { data.Buffer = newVertexBuffer; oldBuffer?.MarkForDisposal(); } if (newTransparentIndexBuffer != null) { data.TransparentIndexBuffer = newTransparentIndexBuffer; oldTransparentIndexBuffer?.MarkForDisposal(); } if (newAnimatedIndexBuffer != null) { data.AnimatedIndexBuffer = newAnimatedIndexBuffer; oldAnimatedIndexBuffer?.MarkForDisposal(); } if (newsolidIndexBuffer != null) { data.SolidIndexBuffer = newsolidIndexBuffer; oldSolidIndexBuffer?.MarkForDisposal(); } } } } else { if (data != null) { data.Dispose(); data = null; } } chunk.IsDirty = chunk.HasDirtySubChunks; //false; chunk.Scheduled = ScheduleType.Unscheduled; if (data != null) { data.Coordinates = coordinates; } _chunkData.AddOrUpdate(coordinates, data, (chunkCoordinates, chunkData) => data); return(true); } catch (Exception ex) { Log.Error(ex, $"Exception while updating chunk: {ex.ToString()}"); } finally { //Enqueued.Remove(new ChunkCoordinates(chunk.X, chunk.Z)); Interlocked.Decrement(ref _chunkUpdates); Monitor.Exit(chunk.UpdateLock); profiler.Stop(); // Log.Info(MiniProfiler.Current.RenderPlainText()); } return(false); }
public MainActivity() { ProfilerService.RegisterInternalEvent("MainActivity Constructor"); }