Unity Memory leaks problem

That TempBuffer is a Temporary Rendertexture rendered at 256x256, probably created by some PostFX (or your Water System?)
Search your codebase for RenderTexture.GetTemporary and check that the created RenderTexture get's cleaned up with RenderTexture.ReleaseTemporary.

 

And thank you for raising the question. We're currently working on the next version of the Memory profiler and within that work it's the second time this week, that the question of "what's the TempBuffer" came up, so I'll see if we can add some more meaning to it in the new UI

 

You're welcome
The code you posted is not implementing a full Dispose pattern which means that, if the garbage collector would clean up TemporaryRenderTexture, its Finalizer would not know it needs to call Dispose and it leaks. Also, relying on the Finalizer is bad and hopefully that Dispose method would be called earlier. Have you looked at all the places where TemporaryRenderTexture is used? It should ideally only be used in a using scope. If not, at the very least Dispose needs to be called on it reliably.

 

For a full description of the dispose pattern, please read through this.
In this case, I'd do something like this:

Code (CSharp):

1. namespace UltimateWater.Internal
2. {
3.     using UnityEngine;
4.     public struct TemporaryRenderTexture : System.IDisposable
5.     {
6.         #region Public Methods
7.         public RenderTexture Texture
8.         {
9.             get { return _RenderTexture; }
10.         }
11.         public void Dispose()
12.         {
13.             Dispose(true);
14.             //If disposing was succesful, this instance does not need to be finalized anymore
15.             GC.SuppressFinalize(this);
16.         }
17.      
18.         public static implicit operator RenderTexture(TemporaryRenderTexture that)
19.         {
20.             return that.Texture;
21.         }
22.         #endregion Public Methods
23.         protected void Dispose(bool disposing)
24.         {
25.             if(disposing || !disposed)
26.             {
27.                 if (_RenderTexture == null) return;
28.    
29.                 _Cache.ReleaseTemporaryDirect(_RenderTexture);
30.                 _RenderTexture = null;
31.                 disposed = true;
32.             }
33.         }
34.      
35.         #region Private Variables
36.         private bool disposed;
37.         private RenderTexture _RenderTexture;
38.         private readonly RenderTexturesCache _Cache;
39.         #endregion Private Variables
40.         #region Private Methods
41.         internal TemporaryRenderTexture(RenderTexturesCache renderTexturesCache)
42.         {
43.             _Cache = renderTexturesCache;
44.             _RenderTexture = renderTexturesCache.GetTemporaryDirect();
45.         }
46.      
47.         // The Finalizer only gets called when an instance of this class was not succesfully disposed before it got Garbage Collected
48.         ~TemporaryRenderTexture()
49.         {
50.             Dispose(false);
51.         }
52.         #endregion Private Methods
53.     }
54. }

While doing that, I realized it has a RenderTexturesCache, that is not a class defined by unity so it likely is part of UltimateWater as well. I'm hoping that this cache is not leaking either and that

_Cache.ReleaseTemporaryDirect(_RenderTexture);

just calls

Code (CSharp):

1. RenderTexture.ReleaseTemporary(_RenderTexture)

.

RenderTextures are not your normal Textures so for rocks and similar that are not using this script, you don't need to do anything. If you're using an IDE like Visual Studio or Monodevelop, you can use that IDE to find all references to TemporaryRenderTexture (or RenderTexturesCache?) and check that everywhere it is used, Dispose is called on it.

 

Regarding:

You can't change the HideFlags for RenderTextures. They are created in native code, the HideFlag keeps them from getting unloaded by UnloadUnusedAssets and they need to be cleaned up manually, which is what this Dispose pattern is supposed to ensure.

 

actually, above Dispose pattern implementation is bad, because it could call

_Cache.ReleaseTemporaryDirect(_RenderTexture);

during finalization when the _Cache might already have been finalized. The order in which objects get finalized is not defined so that should be:

Code (CSharp):

1.  
2.         protected void Dispose(bool disposing)
3.         {
4.             if(disposing)
5.             {
6.                 if (_RenderTexture == null) return;
7.    
8.                 _Cache.ReleaseTemporaryDirect(_RenderTexture);
9.                 _RenderTexture = null;
10.                 disposed = true;
11.             }
12.             else if(!disposed)
13.             {
14.                 if (_RenderTexture == null) return;
15.                 RenderTexture.ReleaseTemporary(_RenderTexture);
16.                 _RenderTexture = null;
17.                 disposed = true;
18.             }
19.         }

Then again, I have no idea what RenderTexturesCache looks like.

also, you might want to read through this thread. Maybe there's something in there or maybe you can raise the question there as well with others who know the system and have access to the code.

 

Adding the finalizer won't fix it looking like a leak. You'll still generate TempBuffers untill GC.Collect is triggered and they are freed. The real fix is to make sure Dispose is called on them at all. So for all those 17 instances check that Dispose is called. If possible, decide and conquer. Meaning, reduce the occurrence of things that use TemporaryRenderTexture in your scene to one half of it and see if it still leaks. If no, try the other half. If yes, half again.

Additionally, it'd be good if you could share the code of RenderTexturesCache.