StepPhysicsWorld Taking Over 100 ms

EternalAmbiguity · Jan 26, 2021

See image below - the StepPhysicsWorld execution seems to take over 100 ms.

I'm clearly doing something wrong. See the second image below:

I have ~2400 of the entity shown in the Inspector in the second image. The map's meshes are entities with colliders, and the player is a moving entity. There's nothing else active in the scene.

The ComponentSystem of the entity shown is below:

Code (csharp):

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using Unity.Jobs;

using UnityEngine.Jobs;

using Unity.Entities;

using Unity.Transforms;

using System.Linq;

using Unity.Mathematics;

using Unity.Physics;

using Unity.Physics.Systems;

using Unity.Collections;

using Unity.Rendering;

using System.Threading.Tasks;

using Unity.Burst;

//[UpdateBefore(typeof(PlayerMovementSystem))]

public class EnemySystem : SystemBase

{

EntityManager em = World.DefaultGameObjectInjectionWorld.EntityManager;

NativeList<UniqueEnemy> allEnemies;

protected override void OnCreate()

{

base.OnCreate();

allEnemies = new NativeList<UniqueEnemy>(Allocator.TempJob);

}

//private ComponentGroup group;

//// Here we define the group

//protected void OnCreateManager()

//{

// // Get all entities with both Position and RigidBody

// group = GetComponentGroup(

// typeof(PlayerInput)

// );

//}

protected override void OnUpdate()

{

var delta = Time.DeltaTime;

var player = em.CreateEntityQuery(typeof(PlayerEntity)).GetSingletonEntity();

var playerPosition = new Tuple(StaticClass.playerCell.Item1, StaticClass.playerCell.Item2);

var mapCorners = StaticClass.mapCorners;

var x0 = mapCorners[0].x;

var x1 = mapCorners[2].x;

var y0 = mapCorners[0].y;

var y1 = mapCorners[2].y;

var grid = StaticClass.GetFlatWalkableGrid();

var positions = StaticClass.GetFlatPositionGrid();

var positionGrid0 = new NativeArray<float3>(positions, Allocator.TempJob);

var positionGrid = positionGrid0.AsReadOnly();

var gridHeight = StaticClass.interactiveGrids[StaticClass.currentLevel].GetLength(1);

var cellWalkable0 = new NativeArray<CellWalkableState>(grid, Allocator.TempJob);

var cellWalkable = cellWalkable0.AsReadOnly();

var enemyType = StaticClass.enemyType;

var weaponCreation = new NativeQueue<WeaponCreationStruct>(Allocator.TempJob);

var parallel = weaponCreation.AsParallelWriter();

List<(int, int)> antisepticList = new List<(int, int)>();

List<(int, int)> poisonList = new List<(int, int)>();

if (StaticClass.ca != null)

{

antisepticList = StaticClass.ca.ActiveCells.Where(x => x.Atmosphere == CellAtmosphere.Antiseptic).Select(y => (y.X, y.Y)).ToList();

antisepticList = antisepticList.Distinct().ToList();

poisonList = StaticClass.ca.ActiveCells.Where(x => x.Atmosphere == CellAtmosphere.Poison).Select(y => (y.X, y.Y)).ToList();

poisonList = poisonList.Distinct().ToList();

}

var antisepticA = new NativeArray<int>(antisepticList.Select(x => x.Item1).ToArray(), Allocator.TempJob);

var antisepticReaderA = antisepticA.AsReadOnly();

var antisepticB = new NativeArray<int>(antisepticList.Select(x => x.Item2).ToArray(), Allocator.TempJob);

var antisepticReaderB = antisepticB.AsReadOnly();

int antisepticLength = antisepticA.Length;

var poisonA = new NativeArray<int>(poisonList.Select(x => x.Item1).ToArray(), Allocator.TempJob);

var poisonReaderA = poisonA.AsReadOnly();

var poisonB = new NativeArray<int>(poisonList.Select(x => x.Item2).ToArray(), Allocator.TempJob);

var poisonReaderB = poisonB.AsReadOnly();

int poisonLength = poisonA.Length;

var damaged = new NativeQueue<Entity>(Allocator.TempJob);

var damagedWriter = damaged.AsParallelWriter();

var tracker = new NativeQueue<Tracker>(Allocator.TempJob);

var trackerParallel = tracker.AsParallelWriter();

var patrol = new NativeQueue<Tracker>(Allocator.TempJob);

var patrolParallel = patrol.AsParallelWriter();

var melee = new NativeQueue<float>(Allocator.TempJob);

var meleeParallel = melee.AsParallelWriter();

var currentEntities = new NativeQueue<UniqueEnemy>(Allocator.TempJob);

var currentEntityWriter = currentEntities.AsParallelWriter();

var traps = new NativeQueue<TrapStruct>(Allocator.TempJob);

var trapWriter = traps.AsParallelWriter();

var currentAllEnemies = allEnemies.AsArray().AsReadOnly();

int enemyLength = allEnemies.Length;

var meleeSpeed = StaticClass.meleeSpeed;

var actionThreshold = StaticClass.shootThreshold;

Entities

.WithName("EnemySystem")

.WithBurst(Unity.Burst.FloatMode.Default, Unity.Burst.FloatPrecision.Standard, true)

.ForEach((Entity entity, int nativeThreadIndex, ref Translation translation, ref Rotation rotation, ref EnemyEntity enemy, in LocalToWorld localToWorld) =>

{

currentEntityWriter.Enqueue(new UniqueEnemy { id = entity.Index, version = entity.Version, enemy = enemy, position = translation.Value});

if(enemy.state >= 0 && enemy.state < 6)

{

for (int i = 0; i < antisepticLength; i++)

{

if(enemy.X.Equals(antisepticReaderA[i]) && enemy.Y.Equals(antisepticReaderB[i]))

{

damagedWriter.Enqueue(entity);

}

}

}

else if (enemy.state >= 6)

{

for (int i = 0; i < poisonLength; i++)

{

if (enemy.X.Equals(poisonReaderA[i]) && enemy.Y.Equals(poisonReaderB[i]))

{

damagedWriter.Enqueue(entity);

}

}

}

if (enemy.state >= 2)

{

WeaponType type = (enemy.state < 6) ? WeaponType.MainBio : WeaponType.MainEn;

if (enemy.oldPosition.Equals(enemy.newPosition) == false)

{

enemy.lerp += (delta * enemy.speed);

// move

float3 newPosition = Vector3.Lerp(enemy.oldPosition, enemy.newPosition, enemy.lerp);

translation.Value = newPosition;

if (enemy.lerp > 1)

{

enemy.lerp = 0;

enemy.oldPosition = enemy.newPosition;

}

}

if (enemy.state == 2) // spinner

{

rotation.Value = math.mul(rotation.Value, quaternion.AxisAngle(Vector3.up, 1 * delta));

if (enemy.actionValue > actionThreshold)

{

var front = translation.Value + (localToWorld.Forward * 1.5f);

var frontDir = Quaternion.LookRotation(localToWorld.Forward, localToWorld.Up);

var right = translation.Value + (localToWorld.Right * 1.5f);

var rightDir = Quaternion.LookRotation(localToWorld.Right, localToWorld.Up);

var back = translation.Value - (localToWorld.Forward * 1.5f);

var backDir = Quaternion.LookRotation(-localToWorld.Forward, localToWorld.Up);

var left = translation.Value - (localToWorld.Right * 1.5f);

var leftDir = Quaternion.LookRotation(-localToWorld.Right, localToWorld.Up);

CreateWeapon(front, frontDir, localToWorld.Forward * 55, type, x0, y0, x1, y1, parallel);

CreateWeapon(back, backDir, -localToWorld.Forward * 55, type, x0, y0, x1, y1, parallel);

CreateWeapon(left, leftDir, -localToWorld.Right * 55, type, x0, y0, x1, y1, parallel);

CreateWeapon(right, rightDir, localToWorld.Right * 55, type, x0, y0, x1, y1, parallel);

enemy.actionValue = 0;

}

}

else if (enemy.state == 3) // aimer // attack random

{

var view = GetInView(entity, enemy, currentAllEnemies, enemyLength, playerPosition, cellWalkable, gridHeight);

// if in range and if in view

if (view.Distance > 0)

{

var pos = positionGrid[(view.X * gridHeight) + view.Y];

var targetPoint = pos - translation.Value;

var rotationSet = quaternion.LookRotation(targetPoint, localToWorld.Up);

if (view.Distance < 20)

{

rotation.Value = rotationSet;

if (enemy.actionValue > actionThreshold)

{

quaternion direction;

if(view.index == -1)

{

direction = Quaternion.LookRotation(localToWorld.Forward, localToWorld.Up);

}

else

{

var asa = currentAllEnemies[view.index].position - translation.Value;

direction = quaternion.Euler(asa);

}

CreateWeapon(translation.Value + (localToWorld.Forward * 1.5f), direction, localToWorld.Forward * 55, type, x0, y0, x1, y1, parallel);

enemy.actionValue = 0;

}

}

else

{

trackerParallel.Enqueue(new Tracker() { X = enemy.X, Y = enemy.Y, X2 = view.X, Y2 = view.Y });

}

}

else

{

trackerParallel.Enqueue(new Tracker() { X = enemy.X, Y = enemy.Y, X2 = -1, Y2 = -1 });

}

}

else if (enemy.state == 5) // melee

{

var view = GetInView(entity, enemy, currentAllEnemies, enemyLength, playerPosition, cellWalkable, gridHeight);

//Debug.Log("getting inview");

if (view.Distance > 0)

{

var pos = positionGrid[(view.X * gridHeight) + view.Y];

var targetPoint = pos - translation.Value;

var rotationSet = quaternion.LookRotation(targetPoint, localToWorld.Up);

rotation.Value = rotationSet;

if (view.Distance < 2)

{

// animation hitting and health drop

if (enemy.actionValue > enemy.actionThreshold)

{

meleeParallel.Enqueue(25);

enemy.actionValue = 0;

}

}

else

{

enemy.speed = meleeSpeed;

trackerParallel.Enqueue(new Tracker() { X = enemy.X, Y = enemy.Y, X2 = view.X, Y2 = view.Y });

}

}

else

{

enemy.speed = 3;

}

}

else if (enemy.state == 6) // aimer or turret // attack things first - primarily defense

{

var view = GetInView(entity, enemy, currentAllEnemies, enemyLength, playerPosition, cellWalkable, gridHeight);

// if in range and if in view

if (view.Distance > 0)

{

var pos = positionGrid[(view.X * gridHeight) + view.Y];

var targetPoint = pos - translation.Value;

var rotationSet = quaternion.LookRotation(targetPoint, localToWorld.Up);

if (view.Distance < 30)

{

rotation.Value = rotationSet;

if (enemy.actionValue > actionThreshold)

{

quaternion direction;

if (view.index == -1)

{

direction = Quaternion.LookRotation(localToWorld.Forward, localToWorld.Up);

}

else

{

var asa = currentAllEnemies[view.index].position - translation.Value;

direction = quaternion.Euler(asa);

}

CreateWeapon(translation.Value + (localToWorld.Forward * 1.5f), direction, localToWorld.Forward * 75, WeaponType.MainEn, x0, y0, x1, y1, parallel);

enemy.actionValue = 0;

}

}

}

}

else if (enemy.state == 7)// attack things first - primarily defense

{

var view = GetInView(entity, enemy, currentAllEnemies, enemyLength, playerPosition, cellWalkable, gridHeight);

if (view.Distance > 0)

{

var pos = positionGrid[(view.X * gridHeight) + view.Y];

var targetPoint = pos - translation.Value;

var rotationSet = quaternion.LookRotation(targetPoint, localToWorld.Up);

if (view.Distance < 200)

{

rotation.Value = rotationSet;

// speak/make noise

if (view.Distance < 100)

{

if (enemy.actionValue > actionThreshold)

{

quaternion direction;

if (view.index == -1)

{

direction = Quaternion.LookRotation(localToWorld.Forward, localToWorld.Up);

}

else

{

var asa = currentAllEnemies[view.index].position - translation.Value;

direction = quaternion.Euler(asa);

}

CreateWeapon(translation.Value + (localToWorld.Forward * 1.5f), direction, localToWorld.Forward * 55, WeaponType.MainEn, x0, y0, x1, y1, parallel);

enemy.actionValue = 0;

}

}

trackerParallel.Enqueue(new Tracker() { X = enemy.X, Y = enemy.Y, X2 = view.X, Y2 = view.Y });

}

}

else

{

patrolParallel.Enqueue(new Tracker() { X = enemy.X, Y = enemy.Y });

}

}

enemy.actionValue += 1 * delta;

}

})

.ScheduleParallel();

Dependency.Complete();

var enemies = currentEntities.ToArray(Allocator.TempJob);

allEnemies.Clear();

allEnemies.AddRange(enemies);

enemies.Dispose();

if (weaponCreation.Count > 0)

{

int count = weaponCreation.Count;

for (int i = 0; i < count; i++)

{

var current = weaponCreation.Dequeue();

Entity create = (current.weaponEntity.type == WeaponType.MainBio) ? StaticClass.entityWeaponBio : StaticClass.entityWeaponEn;

var instance = EntityManager.Instantiate(create);

EntityManager.SetComponentData(instance, new Translation { Value = current.position });

EntityManager.SetComponentData(instance, new Rotation { Value = current.rotation });

EntityManager.SetComponentData(instance, new Unity.Physics.PhysicsVelocity() { Linear = current.velocity });

EntityManager.SetComponentData(instance, current.weaponEntity);

StaticClass.playAudioShoot(current.position);

}

}

for (int i = 0; i < tracker.Count; i++)

{

var cur = tracker.Dequeue();

StaticClass.SetTracker(cur.X, cur.Y, cur.X2, cur.Y2);

}

for (int i = 0; i < patrol.Count; i++)

{

var cur = patrol.Dequeue();

StaticClass.SetPatrol(cur.X, cur.Y);

}

for (int i = 0; i < melee.Count; i++)

{

var cur = melee.Dequeue();

StaticClass.DamagePlayer(WeaponType.Melee);

}

for (int i = 0; i < damaged.Count; i++)

{

StaticClass.DamageEnemy(damaged.Dequeue(), WeaponType.Atmosphere);

}

for (int i = 0; i < traps.Count; i++)

{

var cur = traps.Dequeue();

var loc = StaticClass.CoordinatesFromWorldSpace(cur.position);

cur.enemy.X = loc.Item1;

cur.enemy.Y = loc.Item2;

em.SetComponentData(cur.entity, cur.enemy);

}

currentEntities.Dispose();

melee.Dispose();

tracker.Dispose();

patrol.Dispose();

weaponCreation.Dispose();

cellWalkable0.Dispose();

positionGrid0.Dispose();

damaged.Dispose();

antisepticA.Dispose();

antisepticB.Dispose();

poisonA.Dispose();

poisonB.Dispose();

traps.Dispose();

}

struct TrapStruct

{

public Entity entity;

public EnemyEntity enemy;

public float3 position;

}

struct Truple

{

public int X;

public int Y;

public float Distance;

public int index;

public Truple(int x, int y, float distance, int index)

{

this.X = x;

this.Y = y;

this.Distance = distance;

this.index = index;

}

}

static Truple GetInView(Entity entity, EnemyEntity self, NativeArray<UniqueEnemy>.ReadOnly enemies, int enemyLength, Tuple playerPosition, NativeArray<CellWalkableState>.ReadOnly grid, int gridHeight)

{

NativeArray<int> currentEnemies;

if(self.state < 6) // blob

{

currentEnemies = new NativeArray<int>(3, Allocator.Temp);

currentEnemies[0] = 6;

currentEnemies[1] = 7;

currentEnemies[2] = -1;

}

else if(self.state < 8) // 8 will be

{

currentEnemies = new NativeArray<int>(7, Allocator.Temp);

currentEnemies[0] = -1;

currentEnemies[1] = 0;

currentEnemies[2] = 1;

currentEnemies[3] = 2;

currentEnemies[4] = 3;

currentEnemies[5] = 4;

currentEnemies[6] = 5;

}

else

{

currentEnemies = new NativeArray<int>(9, Allocator.Temp);

currentEnemies[0] = 0;

currentEnemies[1] = 1;

currentEnemies[2] = 2;

currentEnemies[3] = 3;

currentEnemies[4] = 4;

currentEnemies[5] = 5;

currentEnemies[6] = 6;

currentEnemies[7] = 7;

currentEnemies[8] = -1;

}

for (int i = 0; i < enemyLength; i++)

{

var cur = enemies[i];

if(entity.Index.Equals(cur.id) && entity.Version.Equals(cur.version))

{

continue;

}

else

{

if(currentEnemies.Contains(cur.enemy.state))

{

if(InView(self.X, self.Y, cur.enemy.X, cur.enemy.Y, grid, gridHeight))

{

currentEnemies.Dispose();

var distance = math.sqrt(((self.X - cur.enemy.X) * (self.X - cur.enemy.X)) + ((self.Y - cur.enemy.Y) * (self.Y - cur.enemy.Y)));

return new Truple(cur.enemy.X, cur.enemy.Y, distance, i);

}

}

}

}

if (InView(self.X, self.Y, playerPosition.X, playerPosition.Y, grid, gridHeight))

{

currentEnemies.Dispose();

float distance = math.sqrt(((self.X - playerPosition.X) * (self.X - playerPosition.X)) + ((self.Y - playerPosition.Y) * (self.Y - playerPosition.Y)));

return new Truple(playerPosition.X, playerPosition.Y, distance, -1);

}

currentEnemies.Dispose();

return new Truple(-1, -1, -1, -1);

}

struct Tuple

{

public int X;

public int Y;

public Tuple(int x, int y)

{

this.X = x;

this.Y = y;

}

}

struct UniqueEnemy

{

public int id;

public int version;

public EnemyEntity enemy;

public float3 position;

}

protected override void OnDestroy()

{

base.OnDestroy();

allEnemies.Dispose();

}

static void CreateWeapon(float3 position, quaternion direction, float3 velocity, WeaponType type, float x0, float y0, float x1, float y1, NativeQueue<WeaponCreationStruct>.ParallelWriter parallel)

{

parallel.Enqueue(new WeaponCreationStruct()

{

velocity = velocity /** velocity*/,

weaponEntity = new WeaponEntity(type, x0, x1, y0, y1),

position = position, // any lower and it collides with the player when the player moves

rotation = direction,

});

}

static bool InView(int x1, int y1, int x2, int y2, NativeArray<CellWalkableState>.ReadOnly grid, int gridHeight)

{

//Debug.Log("height: " + gridHeight);

NativeList<int> xs = new NativeList<int>(Allocator.Temp);

NativeList<int> ys = new NativeList<int>(Allocator.Temp);

//List<(int, int)> onLine = new List<(int, int)>();

int i; // loop counter

int ystep, xstep; // the step on y and x axis

int error; // the error accumulated during the increment

int errorprev; // *vision the previous value of the error variable

int y = y1, x = x1; // the line points

int ddy, ddx; // compulsory variables: the double values of dy and dx

int dx = x2 - x1;

int dy = y2 - y1;

xs.Add(x1);

ys.Add(y1);

// NB the last point can't be here, because of its previous point (which has to be verified)

if (dy < 0)

{

ystep = -1;

dy = -dy;

}

else

{

ystep = 1;

}

if (dx < 0)

{

xstep = -1;

dx = -dx;

}

else

{

xstep = 1;

}

ddy = 2 * dy; // work with double values for full precision

ddx = 2 * dx;

if (ddx >= ddy)

{ // first octant (0 <= slope <= 1)

// compulsory initialization (even for errorprev, needed when dx==dy)

errorprev = error = dx; // start in the middle of the square

for (i = 0; i < dx; i++)

{ // do not use the first point (already done)

x += xstep;

error += ddy;

if (error > ddx)

{ // increment y if AFTER the middle ( > )

y += ystep;

error -= ddx;

// three cases (octant == right->right-top for directions below):

if (error + errorprev < ddx) // bottom square also

{

xs.Add(x);

ys.Add(y - ystep);

}

else if (error + errorprev > ddx) // left square also

{

xs.Add(x - xstep);

ys.Add(y);

}

else

{ // corner: bottom and left squares also

xs.Add(x);

ys.Add(y - ystep);

xs.Add(x - xstep);

ys.Add(y);

}

}

xs.Add(x);

ys.Add(y);

errorprev = error;

}

}

else

{ // the same as above

errorprev = error = dy;

for (i = 0; i < dy; i++)

{

y += ystep;

error += ddx;

if (error > ddy)

{

x += xstep;

error -= ddy;

if (error + errorprev < ddy)

{

xs.Add(x - xstep);

ys.Add(y);

}

else if (error + errorprev > ddy)

{

xs.Add(x);

ys.Add(y - ystep);

}

else

{

xs.Add(x - xstep);

ys.Add(y);

xs.Add(x);

ys.Add(y - ystep);

}

}

xs.Add(x);

ys.Add(y);

errorprev = error;

}

}

for (int iii = 0; iii < xs.Length; iii++)

{

//Debug.Log("next: " + xs[iii] + ", " + ys[iii]);

var pos = (xs[iii] * gridHeight) + ys[iii];

if (grid[pos] == CellWalkableState.Unwalkable || grid[pos] == CellWalkableState.InteractableObject)

{

return false;

}

}

return true;

}

struct WeaponCreationStruct

{

public WeaponEntity weaponEntity;

public float3 position;

public float3 velocity;

public quaternion rotation;

}

struct Tracker

{

public int X;

public int Y;

public int X2;

public int Y2;

}

}

What could be causing this performance? What does StepPhysicsWorld involve?

EternalAmbiguity · Jan 26, 2021

I was able to use Deep Profile...but it's just as confusing. What is a "JacobianJob"? How do I optimize this?

steveeHavok · Jan 27, 2021

StepPhysicsWorld is performing all the physics Collision Detection and Resolution.
Do you have a the JobsDebugger enabled (see 'Jobs > JobsDebugger' menu item)? This can kill performance.
Do you have a dynamic or kinematic body that has a Physics Shape with a Mesh Collider? If so, this will create a crazy number of contacts to resolve and you should make any Mesh Collider static.

EternalAmbiguity · Jan 27, 2021

Hmm. Not really sure if that fixed anything, but I switched to "Raw Hierarchy" in the profiler and saw something weird.

Looks like now regular physics are taking up a lot of time, but in particular - there are multiple calls of each type (Fixedupdate, StepPhysicsWorld). Is that supposed to happen?

Edit: And the timeline seems to show the same thing - physics is updating twice, in sequence.

EternalAmbiguity · Jan 27, 2021

I realized I'd left an asset (archimatix) enabled that was using Update...I disabled that, and performance is better, but still poor. Another timeline image:

As can be seen from the popup, that's StepPhysicsSystem repeating 10+ times during the same frame. Is that normal?

milos85miki · Jan 28, 2021

Looks like physics was taking too much time in previous steps (longer than fixed timestep) and is now trying to make it up (see Cort's explanation here). What are the fixed timestep and max allowed timestep values in your project settings -> time and what's the first frame when physics step lasted longer than that?

EternalAmbiguity · Jan 28, 2021

Fixed is 0.02, max allowed is 0.333. Don't recall changing them at all, so I assume they're defaults (if I want to target 60 FPS, should the former be 0.016?). Ran again, and this time starting out it was just spikes...

Here it looks like it was the EditorLoop that caused the initial delay, but it looks like my EnemySystem has GC issues...

Related to that, earlier I actually tried to modify it to pull some of those variable assignments outside of the update loop, but had issues doing so. The problem is that some of those things are updated periodically so they'd need to be reassigned within the system. I suppose I could add a bool array to my static class to tell the system to update, but is there any other way to access the system? Such that for instance when I change my cellWalkableState grid, I can call a function in EnemySystem to update that variable outside of the OnUpdate function?

Edit: Okay, for now I just added a bool to my static class, and my performance is back where it needs to be, so crisis averted. However I'd still like to know how to update class (or whatever a SystemBase is) -global variables after start, but not in update.

milos85miki · Jan 28, 2021

From pure programming perspective - would it make sense to create a static method in your EnemySystem and call it for the stuff you need to do outside of update loop (you can also use the static method in OnUpdate, of course)?

Not discussing whether it makes sense to do those frequent updates, you're best suited to make that call since you know the project.

EternalAmbiguity · Jan 28, 2021

milos85miki said: ↑

From pure programming perspective - would it make sense to create a static method in your EnemySystem and call it for the stuff you need to do outside of update loop (you can also use the static method in OnUpdate, of course)?

Not discussing whether it makes sense to do those frequent updates, you're best suited to make that call since you know the project.
Click to expand...

Okay, I was able to do what you suggested, as well as simply add a static bool to the EnemySystem, which allows me to trigger an update to the "class-global" variable in OnUpdate only when needed. Both solutions work, so I consider this resolved.

Thanks for the help.

Search Unity

Unity ID

Useful Searches

StepPhysicsWorld Taking Over 100 ms