[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Public WebGL] [Typed Array] ArrayBuffer Method Request - Dispose

That's not always possible do to. If you are loading data (consider audio samples) into an application via XHR, the data arrives in a new array buffer which is then immediately copied over to an audio buffer. At that point the array buffer becomes useless and is normally dereferenced at the end of the XHR load event, and all of that data ends up floating around in a void until the GC eventually decides to clear it from memory, which is more often than not at a very inconvenient time :)

On 25 February 2013 19:36, Ashley Gullen <ashley@scirra.com> wrote:
Why not just recycle existing array buffers? Create one big one, then create and throw away views on to that buffer, which are small and cheap objects.

On 25 February 2013 19:30, Si Robertson <retromodular@gmail.com> wrote:
Yep, the problem isn't memory not being released, the problem is memory being released "at some point in the future" by the GC. As mentioned previously, array buffers can consume large amounts of system memory especially when working with WebGL and Audio Context at an advanced level, and an application cannot currently dispose of any array buffers even when it knows those array buffers will no longer be needed.

What we are looking at right now is large amounts of system memory being used when there is absolutely no reason for it to be in use. If a game, for example, no longer needs the assets for "level one" when "level two" is loaded into memory, the game should be able to dispose of the level one assets before the level two assets are loaded into memory.

We most definitely need some kind of memory management control with these new APIs. Adding a dispose() method to array buffers will be an ideal solution for most use cases.

Si ++

On 25 February 2013 19:00, Jussi Kalliokoski <jussi.kalliokoski@gmail.com> wrote:
On Mon, Feb 25, 2013 at 1:32 PM, Gregg Tavares <gman@google.com> wrote:
typed arrays are garbage collected just like all JS objects. You can just as easily make large strings or large _javascript_ arrays. _javascript_ will release any unreferenced typed array on it's own just fine. If you have a reproducible case where a typed array is not getting released file a bug for that browser.

The problem isn't that the memory isn't released, quite the contrary, the problem is that the memory is often released at the wrong time, e.g. in the middle of filling a buffer with audio (if you fail at filling the buffer quickly enough, your sounds won't make it to the speakers) or during a drawing operation, causing jitter in the frame rate. Having a manual dispose function to free the buffer would for example let the developer free the memory for example after the buffer is filled with audio, thus reducing the risk of artifacts in the sound.


On Mon, Feb 25, 2013 at 5:12 AM, Si Robertson <retromodular@gmail.com> wrote:
Sorry, my mistake. The method obviously shouldn't have a return value.

interface ArrayBuffer {
    void dispose();

Si ++

On 25 February 2013 10:44, Kirill Prazdnikov <kirill.prazdnikov@jetbrains.com> wrote:

interface ArrayBuffer {
    ArrayBuffer dispose();

What is the purpose of return value ?


On 2/24/2013 9:39 PM, Si Robertson wrote:

I have been studying, and experimenting with, the WebGL API and the Web Audio API recently and have noticed a potential system memory related problem with typed arrays: there is no way to dispose of array buffers when they are no longer needed.

When working with WebGL and/or Web Audio, array buffers can consume large amounts of system memory. Some of these buffers can be treated as permanent/static buffers and reused during the lifetime of an application, but others are temporary and might only be used during a single function call, or might need to be replaced when additional resources are loaded into the application (e.g. game level assets).

It would be extremely useful for programmers if we could explicitly dispose of an array buffer when it is no longer required. Disposing of an array buffer would immediately release any system resources used by the array buffer (e.g. system memory) and reduce the array buffer's length to zero. This would also potentially reduce the amount of work the GC has to do when it eventually decides to clean things up.

I am requesting a single method to be added to the ArrayBuffer type:

interface ArrayBuffer {
    ArrayBuffer dispose();

Most of the other programming languages I use allow these types of arrays to be disposed, for good reasons :)

Si Robertson