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

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

I've found the same issues - in Chrome (at least) there's a severe GC penalty for ArrayBuffers a severe penalty for creating new ArrayBuffers - so I pool or statically cache everything I can. The one place this still bites me is during some loading operations, where the file system API/XHR return array buffers that I will end up dropping almost immediately (as I don't want to store the raw buffer) and cause long GC times. It's fine if the GC occurs during the load operation but it rarely does -- it always happens a second or so into the app, where it's most noticeable. In continuously loading systems that stream in data over XHR/etc a GC of mostly typed arrays can often eat up 100ms, causing many dropped frames. Yuck.

Unfortunately I doubt a dispose() will ever be added due to most web platform decision makers thinking that GC is perfect for all situations ;)

On Mon, Feb 25, 2013 at 11:00 AM, 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