WebSocket onmessage frequente zero-copy

Question

Ho un'app che riceve frequentemente messaggi binari su una WebSocket (almeno una volta per frame) e traccia i dati, usando canvas/webgl. Ho notato che ho un profilo di memoria del dente di sega piuttosto buono; molti pezzi di dati di breve durata.

Questo non mi sorprende dal momento che sto ricevendo un oggetto da onmessage, almeno una volta ogni 16 ms, che viene utilizzato per il disegno e poi de-reference.

La mia domanda è: ci sono suggerimenti per evitare/minimizzare questo? In base allo WebSocket API, non sembra essere un'alternativa all'aver ricevuto una nuova memoria allocata su ogni chiamata di ricezione socket. In un'altra lingua/ambiente, pre-allocare un po 'di memoria e ricevere in quel buffer, per evitare di allocare costantemente memoria per oggetti di breve durata, ma non riesco a pensare ad alcun modo ovvio per ottenere ciò in JavaScript nel browser.

Per riferimento, ecco la vista Frames.

Non so se questo tempo di inattività è garbage collection? Qualsiasi intuizione ninja degli strumenti di sviluppo sarebbe molto apprezzata.

Answer 1

Non sono sicuro se ho capito il tuo problema, ma è possibile dichiarare una matrice globale come in qualsiasi altra lingua e usarlo come un buffer circolare, ad esempio:

var buffer = []; 
var bufferLength = 1000; 
var start = 0; 
var end = 0; 
var content = 0; 

socket.onmessage(function(msg) { //msg allocated 
    end %= bufferLength; 
    if (end == start && content != 0) 
     console.log("Buffer is full"); 
    else { 
     content++; 
     buffer[end++] = msg; //reference to msg saved so it's not destroyed at the end of the callback 
    } 
}); 

function getNext() { 
    start %= bufferLength; 
    if (start == end && content == 0) 
     console.log("Buffer is empty"); 
    else { 
     content--; 
     return buffer[start++]; // returns reference to next msg 
    } 
} 

Edit: ho modificato la risposta di essere più chiaro sul ciclo di memoria:

JS allocherà memoria per il messaggio ricevuto su websockets e creerà un riferimento ad esso chiamato msg che verrà assegnato come param nel callback definito per onmessage.

Nota JS GC distruggerà solo quel pezzo di memoria quando non viene più fatto riferimento nel codice.

Quello che faccio sopra è il salvataggio di quel riferimento all'interno di un buffer in modo che il valore non venga distrutto quando il callback è terminato ed è possibile accedervi successivamente usando getNext. Non è necessario allocare nuova memoria perché JS l'ha fatto per te.

Nel caso in cui si voglia clonare o creare una copia diversa di msg, ci sono alcune opzioni differenti. Un semplice opzione che vi permetterà di clonare un oggetto JSON non circolare sarebbe:

var newJSON = JSON.parse(JSON.stringify(msg)); 

È possibile trovare maggiori informazioni sulla allocazione di memoria a JS in https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management