Report PeriodicWave memory usage to v8 so GC can be properly scheduled

third_party/WebKit/Source/modules/webaudio/PeriodicWave.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 69 matching lines @@
 }
 
 PeriodicWave* PeriodicWave::createTriangle(float sampleRate)
 {
     PeriodicWave* periodicWave = new PeriodicWave(sampleRate);
     periodicWave->generateBasicWaveform(OscillatorHandler::TRIANGLE);
     return periodicWave;
 }
 
 PeriodicWave::PeriodicWave(float sampleRate)
-    : m_sampleRate(sampleRate)
+    : m_v8ExternalMemory(0)
+    , m_sampleRate(sampleRate)
     , m_centsPerRange(CentsPerRange)
 {
     float nyquist = 0.5 * m_sampleRate;
     m_lowestFundamentalFrequency = nyquist / maxNumberOfPartials();
     m_rateScale = periodicWaveSize() / m_sampleRate;
     // Compute the number of ranges needed to cover the entire frequency range, assuming
     // kNumberOfOctaveBands per octave.
     m_numberOfRanges = 0.5 + kNumberOfOctaveBands * log2f(periodicWaveSize());
 }
 
+PeriodicWave::~PeriodicWave()
+{
+    adjustV8ExternalMemory(-static_cast<int64_t>(m_v8ExternalMemory));
+}
+
 unsigned PeriodicWave::periodicWaveSize() const
 {
     // Choose an appropriate wave size for the given sample rate.  This allows us to use shorter
     // FFTs when possible to limit the complexity.  The breakpoints here are somewhat arbitrary, but
     // we want sample rates around 44.1 kHz or so to have a size of 4096 to preserve backward
     // compatibility.
     if (m_sampleRate <= 24000) {
         return 2048;
     }
 
@@ skipping 44 matching lines @@
 
     // A value from 0 -> 1 representing what fraction of the partials to keep.
     float cullingScale = pow(2, -centsToCull / 1200);
 
     // The very top range will have all the partials culled.
     unsigned numberOfPartials = cullingScale * maxNumberOfPartials();
 
     return numberOfPartials;
 }
 
+// Tell V8 about the memory we're using so it can properly schedule garbage collects.
+void PeriodicWave::adjustV8ExternalMemory(int delta)
+{
+    v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(delta);

[jochen (gone - plz use gerrit), 2016/01/26 15:33:55]

mainThreadIsolate()

[Daniel Bratell, 2016/01/26 16:19:13]

Is that important?
modules.dll doesn't know how to call that function:

1>  [2/38] LINK_EMBED(DLL) modules.dll
1>  FAILED: L:\src\depot_tools\python276_bin\python.exe gyp-win-tool
link-with-manifests environment.x86 True modules.dll
"L:\src\depot_tools\python276_bin\python.exe gyp-win-tool link-wrapper
environment.x86 False link.exe /nologo /IMPLIB:modules.dll.lib /DLL
/OUT:modules.dll @modules.dll.rsp" 2 mt.exe rc.exe
"obj\third_party\WebKit\Source\modules\modules.modules.dll.intermediate.manifest"
obj\third_party\WebKit\Source\modules\modules.modules.dll.generated.manifest
1>modules.PeriodicWave.obj : error LNK2019: unresolved external symbol "class
v8::Isolate * __cdecl blink::mainThreadIsolate(void)"
(?mainThreadIsolate@blink@@YAPAVIsolate@v8@@XZ) referenced in function "private:
void __thiscall blink::PeriodicWave::adjustV8ExternalMemory(int)"
(?adjustV8ExternalMemory@PeriodicWave@blink@@AAEXH@Z)

[jochen (gone - plz use gerrit), 2016/01/26 17:11:51]

I'm trying to get rid of this method - the embedder should keep track of which
instance of V8 to use.

Anyway, I don't see an easy way to get to the symbol, so it's ok to add it here
:-/

+    m_v8ExternalMemory += delta;
+}
+
 // Convert into time-domain wave buffers.
 // One table is created for each range for non-aliasing playback at different playback rates.
 // Thus, higher ranges have more high-frequency partials culled out.
 void PeriodicWave::createBandLimitedTables(const float* realData, const float* imagData, unsigned numberOfComponents, bool disableNormalization)
 {
     // TODO(rtoy): Figure out why this needs to be 0.5 when normalization is disabled.
     float normalizationScale = 0.5;
 
     unsigned fftSize = periodicWaveSize();
     unsigned halfSize = fftSize / 2;
@@ skipping 26 matching lines @@
         for (i = std::min(numberOfComponents, numberOfPartials + 1); i < halfSize; ++i) {
             realP[i] = 0;
             imagP[i] = 0;
         }
 
         // Clear packed-nyquist and any DC-offset.
         realP[0] = 0;
         imagP[0] = 0;
 
         // Create the band-limited table.
-        OwnPtr<AudioFloatArray> table = adoptPtr(new AudioFloatArray(periodicWaveSize()));
+        unsigned waveSize = periodicWaveSize();
+        OwnPtr<AudioFloatArray> table = adoptPtr(new AudioFloatArray(waveSize));
+        adjustV8ExternalMemory(waveSize * sizeof(float));
         m_bandLimitedTables.append(table.release());
 
         // Apply an inverse FFT to generate the time-domain table data.
         float* data = m_bandLimitedTables[rangeIndex]->data();
         frame.doInverseFFT(data);
 
         // For the first range (which has the highest power), calculate its peak value then compute normalization scale.
         if (!disableNormalization) {
             if (!rangeIndex) {
                 float maxValue;
@@ skipping 85 matching lines @@
 
         realP[n] = 0;
         imagP[n] = b;
     }
 
     createBandLimitedTables(realP, imagP, halfSize, false);
 }
 
 } // namespace blink