by Marco Trivellato - In this presentation we will provide in-depth knowledge about the Unity runtime. The first part will focus on memory and how to deal with fragmentation and garbage collection. The second part will cover implementation details and their memory vs cycles tradeoffs in both Unity4 and the upcoming Unity5.

1. Internals: Memory and Performance
Codemotion
Milano, 29/11/2014

2. About me
Field Engineer @ Unity Technologies
Past:
o Worked as Software Engineer on several
games at EA, Next Level Games, Milestone

3. Agenda
• Quick Update
• Memory Overview
• Memory vsCycles
• Graphics
• Scripting

4. Latest News
• New CEO
• Unity 4.6 / New UI
• Unity 5.0
• Support for Apple iOS 64 bit
• WebPlayer

5. Native and Managed Memory, Garbage Collection
MEMORY OVERVIEW

6. Memory Overview
• Native (internal)
– Assets data, game objects and components
– Engine internals
• Managed (Mono)
– Scripts objects (managed DLLs)
– wrappers for Unity objects
• Native Dlls
– User’s and 3rd parties Dlls

7. Managed Memory Internals
• Allocates system heap blocks for internal
allocator
• Will allocate new heap blocks when needed
• Garbage collector cleans up
• Heap blocks are kept in Mono for later use
– Memory can be given back to the system after a
while
– …but it depends on the platform  don’t count
on it
• Fragmentation can cause new heap blocks
even though memory is not exhausted

8. Reference vs Value Types
Value types (bool, int,
float, struct, ...)
• Exist in stack memory
• De-allocated when
removed from the stack
• No Garbage
Reference types
(classes)
• Exist on the heap and
are handled by the
mono/.net GC
• De-allocated when no
longer referenced
• Lots of Garbage

9. Garbage Collection
• Roots are not collected in a GC.Collect
– Thread stacks
– CPU Registers
– GC Handles (used by Unity to hold onto
managed objects)
– Static variables!!
• Collection time scales with managed heap
size
– The more you allocate, the slower it gets

10. Temporary Allocations
• Don’t use FindObjects or LINQ
• Use StringBuilder for string concatenation
• Reuse large temporary work buffers
• ToString()
• .tag  use CompareTag() instead

11. Internal Temporary Allocations
Some Examples:
– GetComponents<T>
– Vector3[] Mesh.vertices
– Camera[] Camera.allCameras
– foreach
• does not allocate by definition
• However, there can be a small allocation, depending on
the implementation of .GetEnumerator()
5.x: We are working on new non-allocating versions

12. Data Layout
struct Stuff
{
int a;
float b;
bool c;
string name;
};
Stuff[] arrayOfStuff;
int[] As;
float[] Bs;
bool[] Cs;
string[] names;

13. Memory Fragmentation
• Memory fragmentation is hard to account for
– Fully unload dynamically allocated content
– Switch to a blank scene before proceeding to next
level
• This scene could have a hook where you may pause the
game long enough to sample if there is anything significant in
memory
• Ensure you clear out variables so GC.Collect will
remove as much as possible
• Avoid allocations where possible
• Reuse objects where possible within a scene play
• Clear them out for map load to clean the memory

14. Wrappers: Disposable Types
Some Objects used in scripts have large
native backing memory in unity
– Memory not freed for some time…
Managed Native
WWW
Compressed file
Decompression buffer
Decompressed file

15. Garbage Collection
• GC.Collect
– Runs on the main thread when
• Mono exhausts the heap space
• Or user calls System.GC.Collect()
• Finalizers
– Run on a separate thread
• Controlled by mono
• Can have several seconds delay
• Unity native memory
– Dispose() cleans up internal memory
• Eventually called from finalizer
• Manually call Dispose() to cleanup
Main thread Finalizer thread
www = null;
new(someclass);
//no more heap
-> GC.Collect();
www.Dispose();

16. Wrappers for Unity Objects
• Inherit from Object
• Types:
– GameObject
– Assets: Texture2D, AudioClip, Mesh, etc…
– Components: MeshRenderer, Transform,
MonoBehaviour
• Native Memory is released when Destroy
is called

17. Best Practices
• Reuse objects  Use object pools
• Prefer stack-based allocations  Use
struct instead of class
• System.GC.Collect can be used to trigger
collection
• Calling it 6 times returns the unused
memory to the OS
• Manually call Dispose to cleanup
immediately

18. Writable Meshes, Static & Dynamic Batching
MEMORY VS CYCLES

19. Mesh Read/Write Option
• It allows you to modify the mesh at run-time
• If enabled, a system-copy of the Mesh will
remain in memory
• It is enabled by default
• In some cases, disabling this option will
not reduce the memory usage
– Skinned meshes
– iOS

20. Non-Uniform scaled Meshes
We need to correctly transform vertex normals
• Unity 4.x:
– transform the mesh on the CPU
– create an extra copy of the data
• Unity 5.0
– Scaled on GPU
– Extra memory no longer needed

21. Static Batching
What is it ?
• It’s an optimization that reduces number of draw calls
and state changes
How do I enable it ?
• In the player settings + Tag the object as static

22. Static Batching cont.ed
How does it work internally ?
• Build-time: Vertices are transformed to world-space
• Run-time: Index buffer is created with indices
of visible objects
Unity 5.0:
• Re-implemented static batching without
copying of index buffers
• Beware of misleading stats

23. Dynamic Batching
What is it ?
• Similar to Static Batching but it batches non-static
objects at run-time
How do I enable it ?
• In the player settings
• no need to tag. it auto-magically works…

24. Dynamic Batching cont.ed
How does it work internally ?
• objects are transformed to world space on
the CPU
• Temporary VB & IB are created
• Rendered in one draw call

25. Render Paths, Command Buffers, Shadows
GRAPHICS

26. Render Paths
• Vertex Lit
• Forward Rendering
• First pass for ambient + directional light
• One additional pass for each light hitting the object
• Deferred Lighting
• Two Geometry passes + Lighting
• GBuffer: Normal + Specular, Depth

27. Deferred Shading
• New Render Path in Unity 5
• Only one Geometry pass
• On Platforms with MRTs
• Fallback is Forward Rendering

28. Deferred Shading
Depth buffer + 4x32bit RTs:
• RT0: diffuse color (rgb), unused (a)
• RT1: spec color (rgb), roughness (a)
• RT2: normal (rgb), unused (a).
10.10.10.2 when available.
• RT3: emission/light (rgb), unused (a)
• Z: depth buffer & stencil

29. Command Buffers
• Command buffers
hold list of
rendering
commands
• They can be set to
execute at various
points during
camera rendering

30. Shadows
• Directional Light:
• Use CSM, up to 4 cascades
• they are rendered into screen space to a
32bit RT
• Point Light:
• Render 6 cube faces
• Spot Light:
• One shadow map per light

31. Mesh Skinning
Different Implementations depending on platform:
• x86: SSE
• iOS/Android/WP8: Neon optimizations
• D3D11/XBoxOne/GLES3.0: GPU
• XBox360, WiiU: GPU (memexport)
• PS3: SPU
• WiiU: GPU w/ stream out
Unity 5.0: Skinned meshes use less memory by
sharing index buffers between instances

32. Best Practices
• Try different Render Paths
– Performance depends on scene and platform
• Mix Realtime and Baked Lighting
• Use Level-Of-Detail Techniques
– Mesh, Texture, Shader

33. Scripting API and JIT compilation performance, allocations
SCRIPTING

34. GetComponent<T>
It asks the GameObject, for a component of
the specified type:
• The GO contains a list of Components
• Each Component type is compared to T
• The first Component of type T (or that
derives from T), will be returned to the
caller
• Not too much overhead but it still needs to
call into native code

35. Property Accessors
• Most accessors will be removed in Unity 5.0
• The objective is to reduce dependencies,
therefore improve modularization
• Transform will remain
• Existing scripts will be converted. Example:
in 5.0:

36. Transform Component
• this.transform is the same as GetComponent<Transform>()
• transform.position/rotation needs to:
– find Transform component
– Traverse hierarchy to calculate absolute position
– Apply translation/rotation
• transform internally stores the position relative to the parent
– transform.localPosition = new Vector(…)  simple
assignment
– transform.position = new Vector(…)  costs the same if
no father, otherwise it will need to traverse the hierarchy
up to transform the abs position into local
• finally, other components (collider, rigid body, light, camera,
etc..) will be notified via messages

37. WWW class properties
WWW.texture: Allocates a new Texture2D
…another example is WWW.audioClip

38. Object.Instantiate
API:
• Object Instantiate(Object, Vector3, Quaternion);
• Object Instantiate(Object);
Implementation:
• Clone GameObject Hierarchy and Components
• Copy Properties
• Awake
• Apply new Transform (if provided)

39. Object.Instantiate cont.ed
• Awake can be expensive
• AwakeFromLoad (main thread)
– clear states
– internal state caching
– pre-compute
Unity 5.0:
• Allocations have been reduced
• Some inner loops for copying the data have been
optimized

40. JIT Compilation
What is it ?
• The process in which machine code is generated from
CIL code during the application's run-time
Pros:
• It generates optimized code for the current platform
Cons:
• Each time a method is called for the first time, the
application will suffer a certain performance penalty
because of the compilation

41. JIT compilation spikes
What about pre-JITting ?
• RuntimeHelpers.PrepareMethod does not work:
…better to use MethodHandle.GetFunctionPointer()

42. CONCLUSIONS

43. Best Practices
• Don’t make assumptions
• Platform X != Platform Y
• Profile on target device
• Editor != Player
• Managed Memory is not returned to Native
Land!
• For best results…: Profile early and regularly

44. Want to know more ?
• Unite: http://unity3d.com/unite/archive
• Blog: http://blog.unity3d.com
• Forum: http://forum.unity3d.com
• Support: support@unity3d.com

45. That’s it!
Questions?
@m_trive | marcot@unity3d.com