"Komatsu teaches you to tour the development" "Unity Practical Skills" Unity memory request and release (go from Tnqiang)

Here, we declare the transfer from HTTP://WWW.JIANSHU.COM/P/B37EE8CEA04C.

1. Resource types

Gameobject, Transform, Mesh, Texture, Material, Shader, script and various other assets.

2. How resources are created

• Static references, add a public gameobject variable in the script, drag a prefab to the variable in the Inspector panel, and then instantiate where the reference is needed;
• Resource.load, resources need to be placed in the Assets/resources directory;
• Assetbundle.load, instantiate after Load. 3. Methods of destruction of resources
• Gameobject.destroy (Gameobject), destroying the object;
• Assetbundle.unload (false), frees the Assetbundle file memory image and does not destroy the assets object created by load;
• Assetbundle.unload (TRUE), releases the Assetbundle file memory image while destroying all assets memory images that have been load;
• Resources.unloadasset (object), releasing the loaded asset object;
• Resources.unloadunusedassets, releases all asset objects that are not referenced. 4. The life cycle experiment has created a simple scenario in which an empty gameobject is created, a script is hung on it, and a awake function is created to create resources in the Coroutine function.
  The prefab created in the experiment was a tank car, adding about 3M of scene memory in the scene, while creating a assetbundle resource for assetbundle use. 1. Resources.load mode to load a prefab, and then instantiate Gameobject code as follows:

IEnumerator loadresources () {Clean up to avoid affecting test results resources.unloadunusedassets ();Wait 5 seconds to see the effectYieldReturnNew Waitforseconds (5.0f);Load a resource through resources.load gameobject tank = resources.load ("Role/tank")As Gameobject;YieldReturnNew Waitforseconds (0.5f); //instantiate a resource out gameobject Tankinst = gameobject.instantiate (tank, Vector3.zero, quaternion.identity) as gameobject; yield return new WaitForSeconds ( 0.5f); //Destroy A Resource Gameobject.destroy (tankinst); yield return new WaitForSeconds ( 0.5f); //release useless resources tank = null; Resources.unloadunusedassets (); yield return new WaitForSeconds ( 0.5f); } 

The results of the implementation are as follows:

Here are the statistical results:

Total

Data Description	Memory	Texture	Mesh	Material	gameobjects	Objects in Scene	Objects
Initial	72.8M	1271/8.0m	35/223.0k	25/10.2k	7	211	2187
Resources.load	72.8M	1271/8.0m	36/0.8m	25/10.2k	7	211	2280
Instantiate	75.3M	1272/9.3m	36/0.8m	26/10.7k	52	303	2375
Destroy	74.7M	1272/9.3m	36/0.8m	26/10.7k	7	211	2283
Resources.unloadunusedassets	72.3M	1271/8.0m	35/223.0k	25/10.2k	7	211	2187

From here we draw the following conclusions:

• Resouces.load A prefab is a relatively lightweight operation relative to instantiate a resource, resources.load loading a prefab consumes almost no memory, while instantiate consumes 2.5M of resource space. Resources.load increases the number of mesh and total objects, while instantiate increases the number of gameobjects,objects in scene and Total Objects;
• Destroy after a gameobject, memory is reduced, but less, in this case, the material and texture in this example are reduced by 0.6m;instantiate and destroy, and are not restored to continue the instantiate later.

If Resources.unloadunusedassets is not called, the result is as follows:

The statistical results are as follows:

Total

Data Description	Memory	Texture	Mesh	Material	gameobjects	Objects in Scene	Objects
Initial	58.9M	1258/7.5m	34/219.2k	22/9.0k	7	117	2078
Resources.load	60.0M	1258/7.5m	35/0.8m	22/9.0k	7	117	2171
Instantiate	62.5M	1259/8.9m	36/0.8m	23/9.5k	52	209	2256
Destroy	61.8M	1259/8.9m	35/0.8m	23/9.5k	7	117	2174

The following conclusions are drawn:
If you do not perform resources.unloadunusedassets manually, redundant mesh,material and objects are not actively freed.

2. Load a prefab in a assetbundle.load manner, and then instantiate a Gameobject

The code is as follows:

IEnumerator loadassets (string path) {Clean up to avoid affecting test results resources.unloadunusedassets ();Wait 5 seconds to see the effectYieldReturnNew Waitforseconds (5.0f);Create a WWW-class www bundle =New WWW (path);Yieldreturn bundle;YieldReturnNew Waitforseconds (0.5f);Assetbundle.load A ResourceObject obj = bundle.assetBundle.Load ("Tank");YieldReturnNew Waitforseconds (0.5f);Instantiate a resource out gameobject Tankinst = Instantiate (obj)As Gameobject;YieldReturnnew waitforseconds (0.5f); //Destroy A Resource Gameobject.destroy (tankinst); yield return new WaitForSeconds ( 0.5f); //Unload Resources bundle.assetBundle.Unload (false); yield return new WaitForSeconds (0.5f); //release useless resources //obj = null; //resources.unloadunusedassets (); yield return new WaitForSeconds ( 0.5f); } 

The results of the implementation are as follows:

The statistical results are as follows:

Total

Data Description	Memory	Texture	Mesh	Material	gameobjects	Objects in Scene	Objects
Initial	59.9M	1267/7.8m	35/223.0k	25/10.2k	7	127	2099
New WWW	62.0M	1267/7.8m	35/223.0k	25/10.2k	7	127	2099
Assetbundle.load	64.5M	1268/9.2m	36/0.8m	26/10.5k	7	127	2196
Instantiate	65.6M	1268/9.2m	36/0.8m	26/10.7k	52	219	2288
Destroy	63.9M	1268/9.2m	36/0.8m	26/10.7k	7	127	2196
Assetbundle.unload	63.7M	1268/9.2m	36/0.8m	26/10.7k	7	127	2196
Resources.unloadunusedassets	61.8M	1267/7.8m	35/223.0k	25/10.2k	7	127	2099

The following conclusions are drawn:
The mesh,texture and material are loaded automatically when a resource is loaded via the WWW load assetbundle, and loading with the Resouces.load mode loads only the mesh information. As a result, the memory consumption of instantiate a resource is smaller after loading by assetbundle mode, in this case Assetbundle.load adds 2.5M of memory, and instantiate adds 1.1M of memory. The memory increment of instantiate is much smaller compared to resources.load.

3. Instantiate a resource by means of a static binding

The code is as follows:

IEnumerator instresources () {resources.unloadunusedassets ();yield return new WaitForSeconds (        5.0f); Gameobject Inst = gameobject.instantiate (tank, Vector3.zero, quaternion.identity) as Gameobject; yield return new WaitForSeconds ( 1f); Gameobject.destroy (inst); yield return new WaitForSeconds ( 1f); //release useless resources tank = null; Resources.unloadunusedassets (); yield return new WaitForSeconds ( 1f); } 

The results of the implementation are as follows:

The statistical results are as follows:

Total

Data Description	Memory	Texture	Mesh	Material	gameobjects	Objects in Scene	Objects
Initial	62.0M	1268/7.9m	36/0.8m	25/10.2k	7	134	2202
Instantiate	64.4M	1269/9.2m	36/0.8m	26/10.7k	8	137	230V
Destroy	64.0M	1269/9.2m	36/0.8m	26/10.7k	7	134	2204
Unloadunused Resources	62.3M	1268/7.9m	35/226.3k	25/10.2k	7	134	2107

The following conclusions are drawn:
By statically binding the load order of various resources is the same as Resources.load, when a gameobject is created, its component statically bound Gameobject only loads the mesh information, only if the Gameobject Texture and material information will not be loaded until instantiate is released.

Theory Chapter

The process of loading resources can be divided into two phases, the first phase is to load various resources using Resources.load or assetbundle.load, and the second phase is to clone a new gameobject using Gameobject.instantiate.
The types of load resources include Gameobject, Transform, Mesh, Texture, Material, shader, and script. But there is a difference between resources.load and assetbundle.load.
When using Resources.load, the corresponding asset object was not created until the first instantiate, and it was not actually read until the first instantiate to create these assets. Its purpose is to implement a way of using OnDemand to create these resources when the resource is actually used.
When using the Assetbundle.load method, the resource files are read directly to create these assets, so the first instantiate will be relatively small.
These differences can help us explain why there is a noticeable lag when launching the first bullet.

Then let's get back to the instantiate process. The process of instantiate is a process of combining clone (copy) and reference to assets, and the process of cloning requires the memory to store its own data, whereas the process of referencing only needs to direct a simple pointer to a resource that has already been load. For example, transform is out of clone, texture and Terraindata are copied by reference, and mesh,material,physicalmaterial and script are both clone and reference. In script, for example, the script is divided into code snippets and data segments, all the code that needs to use the script is the same, and everyone's data is different, so you need to use clone for the data segment, and the code snippet needs to be gameobject in the way it is referenced.
So the load operation actually load some data source, which is used to create a new object when it is clone or referenced.

Then is the process of destroying resources. When destory a gameobject or other instance, it releases only those clone assets from the instance, and does not release those referenced assets, because destroy does not know if anyone else is referencing the assets. When no objects in the scene refer to these assets, they become unusedassets, which can be released by Resources.unloadunusedassets. Assetbundle.unload (false) does not work because it frees only the memory image of the file, does not release the resource, and Assetbunde.unload (true) is not possible because it is a release of violence, and there may be other objects referencing the assets, Brute force release can cause program errors.
It is also important to note that all memory objects are automatically destroyed when the system loads a new scene, including resources.load loaded assets, statically bound assets, Assetbundle.load loaded resources and instantiate instantiated objects. However, Assetbundle.load's own file memory image (used to create various asset) is not automatically destroyed, which must be actively destroyed using Assetbundle.unload (false). The recommended practice is to call Assetbunble.unload (false) to destroy the file memory image immediately after the resource is loaded.
Can help understand the relationship between asset and Gameobject in memory.

Concluding article

• In order to avoid the phenomenon of the first instantiate, it is recommended to use Assetbundle.load instead of resources.load to load the resources in a way;
• Immediately after the resource is loaded, call Assetbunble.unload (false) to release the file memory image;
• Unity itself does not provide a good memory application and release management mechanism, destroy a gameobject will immediately release memory instead of internal cache, so the application of frequently used objects such as NPC,FX, such as the object pool management is necessary to reduce the number of memory applications;
• When to Resources.unloadunusedassets is an issue that needs to be discussed.

REF:

http://game.ceeger.com/forum/read.php?tid=4394
http://game.ceeger.com/forum/read.php?tid=4466

Wen/tnqiang (author of Jane's book)
Original link: http://www.jianshu.com/p/b37ee8cea04c
Copyright belongs to the author, please contact the author to obtain authorization, and Mark "book author".

"Komatsu teaches you to tour the development" "Unity Practical Skills" Unity memory request and release (go from Tnqiang)