static UIRRepaintUpdater()
{
UIRRepaintUpdater.s_MarkerDrawChain = new ProfilerMarker("DrawChain");
UIRRepaintUpdater.s_Description = "UIRepaint";
UIRRepaintUpdater.s_ProfilerMarker = new ProfilerMarker(UIRRepaintUpdater.s_Description);
Utility.GraphicsResourcesRecreate += new Action <bool>(UIRRepaintUpdater.OnGraphicsResourcesRecreate);
}
public unsafe void TestRecreateDuplicateMarkersMultithreadedGetCachedOnceInThreads()
{
var markers = CreateMarkersThreadedDuplicates();
ManualResetEvent mre = new ManualResetEvent(false);
Thread[] threads = new Thread[16];
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread((object p) =>
{
int section = (int)p;
mre.WaitOne();
for (int j = 0; j < threads.Length; j++)
{
int index = section * threads.Length + j;
ProfilerMarker marker = new ProfilerMarker($"Test {j}");
Assert.IsTrue(marker.Handle == markers[index]);
}
});
threads[i].Start(i);
}
Thread.Sleep(100);
mre.Set();
for (int i = 0; i < threads.Length; i++)
{
threads[i].Join();
}
}
public void OnCreate(WorldUnmanaged world)
{
m_World = world;
m_TypeArrayIndices = (ushort *)Memory.Unmanaged.Allocate(sizeof(ushort) * kMaxTypes, 16, Allocator.Persistent);
UnsafeUtility.MemSet(m_TypeArrayIndices, 0xFF, sizeof(ushort) * kMaxTypes);
m_ReadJobFences = (JobHandle *)Memory.Unmanaged.Allocate(sizeof(JobHandle) * kMaxReadJobHandles * kMaxTypes, 16, Allocator.Persistent);
UnsafeUtility.MemClear(m_ReadJobFences, sizeof(JobHandle) * kMaxReadJobHandles * kMaxTypes);
m_DependencyHandles = (DependencyHandle *)Memory.Unmanaged.Allocate(sizeof(DependencyHandle) * kMaxTypes, 16, Allocator.Persistent);
UnsafeUtility.MemClear(m_DependencyHandles, sizeof(DependencyHandle) * kMaxTypes);
m_JobDependencyCombineBufferCount = 4 * 1024;
m_JobDependencyCombineBuffer = (JobHandle *)Memory.Unmanaged.Allocate(sizeof(DependencyHandle) * m_JobDependencyCombineBufferCount, 16, Allocator.Persistent);
m_DependencyHandlesCount = 0;
_IsInTransaction = false;
IsInForEachDisallowStructuralChange = 0;
m_ExclusiveTransactionDependency = default;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
Safety.OnCreate();
#endif
m_Marker = new ProfilerMarker("CompleteAllJobs");
}
//---------------------------------------------------------------------------------------------------
// TEST WORST CASE SCENARIO OF DUPLICATE MARKERS CREATED CONCURRENTLY ALL IN ONE BUCKET
//---------------------------------------------------------------------------------------------------
private IntPtr[] CreateMarkersThreadedDuplicates()
{
ManualResetEvent mre = new ManualResetEvent(false);
IntPtr[] markers = new IntPtr[256];
Thread[] threads = new Thread[16];
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread((object p) =>
{
int section = (int)p;
mre.WaitOne();
for (int j = 0; j < threads.Length; j++)
{
int index = section * threads.Length + j;
ProfilerMarker marker = new ProfilerMarker($"Test {j}");
markers[index] = marker.Handle;
}
});
threads[i].Start(i);
}
Thread.Sleep(100);
mre.Set();
for (int i = 0; i < threads.Length; i++)
{
threads[i].Join();
}
return(markers);
}
protected override void OnCreate()
{
_eachEntity = new ProfilerMarker("StyleSystem.EachEntity");
_matchMarker = new ProfilerMarker("StyleSystem.FindMatches");
_applyMatching = new ProfilerMarker("StyleSystem.ApplyMatching");
base.OnCreate();
}
protected override void OnCreate()
{
m_beginBarrier = World.GetOrCreateSystem <BeginSimulationEntityCommandBufferSystem>();
m_NetworkReceiveSystemGroup = World.GetOrCreateSystem <NetworkReceiveSystemGroup>();
m_NetworkTimeSystem = World.GetOrCreateSystem <NetworkTimeSystem>();
m_fixedUpdateMarker = new ProfilerMarker("ClientFixedUpdate");
}
protected override unsafe void OnUpdate()
{
var ecbSource = World.GetOrCreateSystem <DotsNavSystemGroup>().EcbSource;
var buffer = ecbSource.CreateCommandBuffer().AsParallelWriter();
var removeQueue = _toRemoveQueue;
var toRemoveWriter = removeQueue.AsParallelWriter();
var loadMarker = new ProfilerMarker("Loading");
var updatingMarker = new ProfilerMarker("Updating");
var vertexBuffer = _vertexBuffer;
var amounts = _amounts;
var entities = _entities;
// Queue insert obstacles without LocalToWorld
Entities
.WithBurst()
.WithNone <ObstacleSystemStateComponent>()
.WithNone <Translation, Rotation, Scale>().WithNone <NonUniformScale, LocalToWorld>()
.ForEach((Entity entity, int entityInQueryIndex, ObstacleComponent data, VertexBlobComponent blob) =>
{
ref var vertices = ref blob.BlobRef.Value.Vertices;
vertexBuffer.AddRange(vertices.GetUnsafePtr(), vertices.Length);
amounts.Add(vertices.Length);
entities.Add(entity);
buffer.AddComponent(entityInQueryIndex, entity, new ObstacleSystemStateComponent());
})
public unsafe void TestProfilerSessionEmitsMarkerInfoBeforeMarker()
{
SpoofInitListenInternal();
Connection.ConnectDirect(spoofIp, spoofPort);
Baselib_Timer_WaitForAtLeast(200);
SpoofAcceptInternal();
ProfilerTestFixture.ReceiveConnectMessage();
#if !NET_DOTS
HashSet <uint> markerDefined = new HashSet <uint>();
#else
Dictionary <uint, bool> markerDefined = new Dictionary <uint, bool>();
#endif
for (int i = 0; i < 8; i++)
{
for (ulong j = 0; j < 8; j++)
{
ProfilerMarker marker = new ProfilerMarker($"{Baselib_Timer_GetHighPrecisionTimerTicks() + j} test");
ProfilerMarker marker2 = new ProfilerMarker($"{Baselib_Timer_GetHighPrecisionTimerTicks() + j + 1} test2");
marker.Begin();
marker2.Begin();
marker2.End();
marker.End();
}
ProfilerProtocolSession.SendNewMarkersAndThreads();
SendAndValidate(markerDefined);
}
SpoofExitInternal();
}
protected override void OnCreate()
{
base.OnCreate();
m_ServerTick = 1;
m_fixedUpdateMarker = new ProfilerMarker("ServerFixedUpdate");
m_currentTime = Time.ElapsedTime;
}
public void Initialize()
{
if (m_Initialized)
{
return;
}
if (m_Object == null)
{
Debug.LogError("A pool cannot have a null object as template for pool object", this);
return;
}
var profileMarker = new ProfilerMarker("Pool.Initialize");
profileMarker.Begin(this);
m_Available = new Stack <Node>(m_DefaultSize);
m_InUse = new Dictionary <GameObject, Node>(m_DefaultSize);
m_OriginalObject = m_Object; //Lock in original object so it's not affected by serialization change
m_PoolRoot = PoolManager.CreatePoolRoot(name);
m_Capacity = 0;
EnsureCapacity(m_DefaultSize);
m_Initialized = true;
profileMarker.End();
}
protected override void OnCreate()
{
base.OnCreate();
AddSystemToUpdateList(World.GetOrCreateSystem <NetworkReceiveSystemGroup>());
m_ServerTick = 1;
m_fixedUpdateMarker = new ProfilerMarker("ServerFixedUpdate");
}
static void Internal_CallUpdateFunctions()
{
if (update != null)
{
if (Profiler.enabled && !ProfilerDriver.deepProfiling)
{
var currentUpdateHash = update.GetHashCode();
if (currentUpdateHash != m_UpdateHash)
{
m_UpdateInvocationList = update.GetInvocationList();
m_UpdateHash = currentUpdateHash;
}
foreach (var cb in m_UpdateInvocationList)
{
var marker = new ProfilerMarker(cb.Method.Name);
marker.Begin();
cb.DynamicInvoke(null);
marker.End();
}
}
else
{
update.Invoke();
}
}
}
static TextureBlitter()
{
TextureBlitter.s_CommitSampler = new ProfilerMarker("UIR.TextureBlitter.Commit");
TextureBlitter.k_TextureIds = new int[8];
for (int i = 0; i < 8; i++)
{
TextureBlitter.k_TextureIds[i] = Shader.PropertyToID("_MainTex" + i.ToString());
}
}
public void BurstedTestProfilerTimeGoesForward()
{
ProfilerMarker marker = new ProfilerMarker("test");
ProfilerMarker marker2 = new ProfilerMarker("test2");
ProfilerMarker marker3 = new ProfilerMarker("test3");
ProfilerMarker marker4 = new ProfilerMarker("test4");
BurstedTestProfilerTimeGoesForwardInternal(ref marker, ref marker2, ref marker3, ref marker4);
}
public unsafe void TestProfilerTimeGoesForward()
{
ProfilerMarker marker = new ProfilerMarker("test");
ProfilerMarker marker2 = new ProfilerMarker("test2");
ProfilerMarker marker3 = new ProfilerMarker("test3");
ProfilerMarker marker4 = new ProfilerMarker("test4");
Assert.DoesNotThrow(() => TestProfilerTimeGoesForwardInternal(ref marker, ref marker2, ref marker3, ref marker4));
}
public static ProfilerMarker.AutoScope Get(string name)
{
if (!markerCache.TryGetValue(name, out var marker))
{
marker = new ProfilerMarker(name);
markerCache[name] = marker;
}
return(marker.Auto());
}
public ColliderAllocationJob(IEnumerable <ICollider> colliderList, PlaneCollider playfieldCollider, PlaneCollider glassCollider) : this()
{
var perfMarker = new ProfilerMarker("ColliderAllocationJob.ctr");
perfMarker.Begin();
_circleColliders = new NativeList <CircleCollider>(Allocator.TempJob);
_flipperColliders = new NativeList <FlipperCollider>(Allocator.TempJob);
_gateColliders = new NativeList <GateCollider>(Allocator.TempJob);
_line3DColliders = new NativeList <Line3DCollider>(Allocator.TempJob);
_lineSlingshotColliders = new NativeList <LineSlingshotCollider>(Allocator.TempJob);
_lineColliders = new NativeList <LineCollider>(Allocator.TempJob);
_lineZColliders = new NativeList <LineZCollider>(Allocator.TempJob);
_plungerColliders = new NativeList <PlungerCollider>(Allocator.TempJob);
_pointColliders = new NativeList <PointCollider>(Allocator.TempJob);
_spinnerColliders = new NativeList <SpinnerCollider>(Allocator.TempJob);
_triangleColliders = new NativeList <TriangleCollider>(Allocator.TempJob);
_planeColliders = new NativeArray <PlaneCollider>(2, Allocator.TempJob)
{
[0] = playfieldCollider,
[1] = glassCollider
};
BlobAsset = new NativeArray <BlobAssetReference <ColliderBlob> >(1, Allocator.TempJob);
// separate created colliders per type
foreach (var collider in colliderList)
{
switch (collider)
{
case CircleCollider circleCollider: _circleColliders.Add(circleCollider); break;
case FlipperCollider flipperCollider: _flipperColliders.Add(flipperCollider); break;
case GateCollider gateCollider: _gateColliders.Add(gateCollider); break;
case LineCollider lineCollider: _lineColliders.Add(lineCollider); break;
case Line3DCollider line3DCollider: _line3DColliders.Add(line3DCollider); break;
case LineSlingshotCollider lineSlingshotCollider: _lineSlingshotColliders.Add(lineSlingshotCollider); break;
case LineZCollider lineZCollider: _lineZColliders.Add(lineZCollider); break;
case PlungerCollider plungerCollider: _plungerColliders.Add(plungerCollider); break;
case PointCollider pointCollider: _pointColliders.Add(pointCollider); break;
case SpinnerCollider spinnerCollider: _spinnerColliders.Add(spinnerCollider); break;
case TriangleCollider triangleCollider: _triangleColliders.Add(triangleCollider); break;
}
}
perfMarker.End();
}
public unsafe void TestRecreateMarkersMultithreadedGetCachedOnce()
{
var markers = CreateMarkersThreaded();
for (int i = 0; i < markers.Length; i++)
{
ProfilerMarker marker = new ProfilerMarker($"Test {i}");
Assert.IsTrue(marker.Handle == markers[i]);
}
}
protected override void OnUpdate()
{
var commandBuffer = _barrier.CreateCommandBuffer().ToConcurrent();
Entities
.WithName("AddBlockBuffersToChunks")
.WithAll <GenerateChunk>()
.WithNone <ChunkBlockType>()
.ForEach((int entityInQueryIndex, Entity e) =>
{
commandBuffer.AddBuffer <ChunkBlockType>(entityInQueryIndex, e);
}).ScheduleParallel();
var blockIDs = GetBlockIDs();
ProfilerMarker marker = new ProfilerMarker("InitChunkBlocks");
Entities
.WithName("InitializeChunkBlocks")
.WithAll <GenerateChunk>()
.ForEach((int entityInQueryIndex, Entity e, ref DynamicBuffer <ChunkBlockType> blocksBuffer,
in ChunkWorldHeight chunkWorldHeight, in RegionHeightMap heightMapBlob, in RegionIndex regionIndex) =>
{
blocksBuffer.ResizeUninitialized(Constants.ChunkVolume);
var blocks = blocksBuffer.AsNativeArray();
ref var heightMap = ref heightMapBlob.Array;
for (int i = 0; i < blocks.Length; ++i)
{
int3 xyz = GridUtil.Grid3D.IndexToPos(i);
int x = xyz.x;
int y = xyz.y;
int z = xyz.z;
int xzIndex = GridUtil.Grid2D.PosToIndex(x, z);
int maxHeight = heightMap[xzIndex];
int height = y + chunkWorldHeight;
if (height <= maxHeight)
{
blocks[i] = SelectBlock(height, maxHeight, ref blockIDs);
}
else
{
blocks[i] = default;
}
}
commandBuffer.RemoveComponent <GenerateChunk>(entityInQueryIndex, e);
commandBuffer.AddComponent <GenerateMesh>(entityInQueryIndex, e);
}).ScheduleParallel();
/// <summary>
/// Constructor.
/// </summary>
public ImmediateModeElement()
{
generateVisualContent += OnGenerateVisualContent;
var type = GetType();
if (!s_Markers.TryGetValue(type, out m_ImmediateRepaintMarker))
{
m_ImmediateRepaintMarker = new ProfilerMarker($"{typeName}.{nameof(ImmediateRepaint)}");
s_Markers[type] = m_ImmediateRepaintMarker;
}
}
static void Init()
{
markerMain = new ProfilerMarker("Main Scheduler");
scheduler = new UnityTaskScheduler("Background");
mainScheduler = new UnityTaskScheduler("Main");
mainThreadTasks = new ConcurrentQueue <Task>();
newTasks = new ConcurrentQueue <ISubJob>();
FrameCount = 0;
}
public unsafe void TestDisableFromPlayerConnectionDoesntSend()
{
ProfilerProtocolThread.Stream.buffer->m_BufferList->RecycleStreamAndFreeExtra();
PlayerConnectionProfiler.Shutdown();
ProfilerMarker marker = new ProfilerMarker("Test marker");
marker.Begin();
marker.End();
Assert.Zero(ProfilerProtocolThread.Stream.buffer->m_BufferList->TotalBytes);
}
public unsafe void TestRecreateDuplicateMarkersMultithreadedGetCachedOnce()
{
var markers = CreateMarkersThreadedDuplicates();
for (int i = 0; i < markers.Length; i += 16)
{
for (int j = 0; j < 16; j++)
{
ProfilerMarker marker = new ProfilerMarker($"Test {j}");
Assert.IsTrue(marker.Handle == markers[i + j]);
}
}
}
public Profile(string name)
{
_name = name;
if (Markers.TryGetValue(_name, out var marker))
{
marker.Begin();
}
else
{
marker = new ProfilerMarker(_name);
Markers.Add(_name, marker);
marker.Begin();
}
}
static void Internal_CallUpdateFunctions()
{
if (update != null)
{
var invocationList = update.GetInvocationList();
foreach (var cb in invocationList)
{
var marker = new ProfilerMarker(cb.Method.Name);
marker.Begin();
cb.DynamicInvoke();
marker.End();
}
}
}
public static void BurstedProfilerMethods(ref ProfilerMarker marker)
{
EnsureBurstedOrThrow();
// These API calls actually prove out a LOT of internal API burst-ability
marker.Begin();
marker.End();
using (marker.Auto())
{
}
ProfilerProtocolThread.SendNewFrame();
}
public unsafe void TestRecreateMarkerJustGetsCached()
{
IntPtr[] markers = new IntPtr[256];
for (int i = 0; i < markers.Length; i++)
{
ProfilerMarker marker = new ProfilerMarker($"Test {i}");
markers[i] = marker.Handle;
}
for (int i = 0; i < markers.Length; i++)
{
ProfilerMarker marker = new ProfilerMarker($"Test {i}");
Assert.IsTrue(marker.Handle == markers[i]);
}
}
void CreateMarkers()
{
if (!string.IsNullOrEmpty(m_PanelName))
{
m_MarkerUpdate = new ProfilerMarker($"Panel.Update.{m_PanelName}");
m_MarkerLayout = new ProfilerMarker($"Panel.Layout.{m_PanelName}");
m_MarkerBindings = new ProfilerMarker($"Panel.Bindings.{m_PanelName}");
m_MarkerAnimations = new ProfilerMarker($"Panel.Animations.{m_PanelName}");
}
else
{
m_MarkerUpdate = new ProfilerMarker("Panel.Update");
m_MarkerLayout = new ProfilerMarker("Panel.Layout");
m_MarkerBindings = new ProfilerMarker("Panel.Bindings");
m_MarkerAnimations = new ProfilerMarker("Panel.Animations");
}
}
public unsafe void TestUnityEngineProfiler()
{
ProfilerProtocolThread.Stream.buffer->m_BufferList->RecycleStreamAndFreeExtra();
// for compatibility
UnityEngine.Profiling.Profiler.BeginSample("SomeMethod.Test");
UnityEngine.Profiling.Profiler.EndSample();
var profileMemA = ProfilerProtocolThread.Stream.buffer->m_BufferList->ToByteArray(0, ProfilerProtocolThread.Stream.buffer->m_BufferList->TotalBytes);
ProfilerProtocolThread.Stream.buffer->m_BufferList->RecycleStreamAndFreeExtra();
ProfilerMarker marker = new ProfilerMarker("SomeMethod.Test");
marker.Begin();
marker.End();
var profileMemB = ProfilerProtocolThread.Stream.buffer->m_BufferList->ToByteArray(0, ProfilerProtocolThread.Stream.buffer->m_BufferList->TotalBytes);
ProfilerProtocolThread.Stream.buffer->m_BufferList->RecycleStreamAndFreeExtra();
const int k_BlockIndexCurr_1 = 28;
const int k_Time_1 = 56;
const int k_BlockIndexNext_1 = 64;
const int k_BlockIndexCurr_2 = 100;
const int k_Time_2 = 128;
const int k_BlockIndexNext_2 = 136;
Assert.NotZero(profileMemA.Length);
Assert.NotZero(profileMemB.Length);
Assert.AreEqual(profileMemA.Length, profileMemB.Length);
for (int i = 0; i < profileMemA.Length; i++)
{
if (i != k_BlockIndexCurr_1 && i != k_BlockIndexNext_1 && i != k_BlockIndexCurr_2 && i != k_BlockIndexNext_2 &&
!(i >= k_Time_1 && i < k_Time_1 + 8) && !(i >= k_Time_2 && i < k_Time_2 + 8))
{
Assert.AreEqual(profileMemA[i], profileMemB[i]);
}
}
Assert.True(profileMemA[k_BlockIndexNext_1] == profileMemA[k_BlockIndexCurr_1] + 1);
Assert.True(profileMemA[k_BlockIndexCurr_2] == profileMemA[k_BlockIndexNext_1]);
Assert.True(profileMemA[k_BlockIndexNext_2] == profileMemA[k_BlockIndexCurr_2] + 1);
Assert.True(profileMemB[k_BlockIndexCurr_1] == profileMemA[k_BlockIndexCurr_1] + 2);
Assert.True(profileMemB[k_BlockIndexNext_1] == profileMemA[k_BlockIndexNext_1] + 2);
Assert.True(profileMemB[k_BlockIndexCurr_2] == profileMemA[k_BlockIndexCurr_2] + 2);
Assert.True(profileMemB[k_BlockIndexNext_2] == profileMemA[k_BlockIndexNext_2] + 2);
}
public unsafe void TestRandomlyCreateAndGetMarkersMultithreaded()
{
ManualResetEvent mre = new ManualResetEvent(false);
const int k_NumTotalMarkers = 65536;
const int k_NumUniqueMarkers = 1024;
string[] markerName = new string[k_NumUniqueMarkers];
System.Random rand = new System.Random();
for (int i = 0; i < k_NumUniqueMarkers; i++)
{
for (int j = 0; j < rand.Next(1, 20); j++)
{
markerName[i] += rand.Next(10).ToString();
}
}
Thread[] threads = new Thread[16];
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread((object p) =>
{
System.Random innerRand = (System.Random)p;
int len = k_NumTotalMarkers / threads.Length;
mre.WaitOne();
for (int j = 0; j < len; j++)
{
ProfilerMarker marker = new ProfilerMarker(markerName[innerRand.Next(k_NumUniqueMarkers)]);
Assert.IsTrue(((Development.Profiling.Profiler.MarkerBucketNode *)marker.m_Ptr)->markerId < k_NumUniqueMarkers);
}
});
System.Random localRand = new System.Random(rand.Next());
threads[i].Start(localRand);
}
Thread.Sleep(100);
mre.Set();
for (int i = 0; i < threads.Length; i++)
{
threads[i].Join();
}
}
