Ticket #931: snd_remove_source_suballoc.patch

snd_mgr.cpp

@@ -409 +409 @@
 
 
 //-----------------------------------------------------------------------------
-// AL source suballocator: allocate all available sources up-front and
-// pass them out as needed (alGenSources is quite slow, taking 3..5 ms per
-// source returned). also responsible for enforcing user-specified limit
-// on total number of sources (to reduce mixing cost on low-end systems).
+// AL source suballocator
 //-----------------------------------------------------------------------------
 
-// regardless of HW capabilities, we won't use more than this ("enough").
-// necessary in case OpenAL doesn't limit #sources (e.g. if SW mixing).
-static const size_t AL_SRC_MAX = 64;
+// a suballocator used to be necessary because alGenSources took 3-5 ms per
+// source returned on NVidia's native OpenAL. however, OS X CoreAudio can't
+// deal with immediate source reuse (race condition?), and the easiest way
+// to get around this is to generate/delete sources on demand. fortunately,
+// OpenALsoft only takes a few microseconds to do this.
+// this layer is also responsible for enforcing the user-specified limit on
+// the total number of sources (to reduce mixing cost on low-end systems).
 
-// (allow changing at runtime)
-static size_t al_src_maxNumToUse = AL_SRC_MAX;
+// 64 is probably "enough", but the value can be changed at runtime.
+static size_t al_src_maxNumToUse = 64;
 
-static size_t al_src_numPreallocated;
+static volatile intptr_t al_src_inUse;
 
-enum AllocationState
-{
-    kAvailable = 0, // (must match zero-initialization of al_srcs_allocationStates)
-    kInUse
-};
 
-// note: we want to catch double-free bugs and ensure all sources
-// are released at exit, but OpenAL doesn't specify an always-invalid
-// source name, so we need a separate array of AllocationState.
-static ALuint al_srcs[AL_SRC_MAX];
-static intptr_t al_srcs_allocationStates[AL_SRC_MAX];
-
-/**
- * grab as many sources as possible up to the limit.
- * called from al_init.
- */
 static void al_src_init()
 {
-    // grab as many sources as possible and count how many we get.
-    for(size_t i = 0; i < al_src_maxNumToUse; i++)
-    {
-        ALuint al_src;
-        alGenSources(1, &al_src);
-        // we've reached the limit, no more are available.
-        if(alGetError() != AL_NO_ERROR)
-            break;
-        ENSURE(alIsSource(al_src));
-        al_srcs[i] = al_src;
-        al_src_numPreallocated++;
-    }
-
-    // limit user's cap to what we actually got.
-    // (in case snd_set_max_src was called before this)
-    if(al_src_maxNumToUse > al_src_numPreallocated)
-        al_src_maxNumToUse = al_src_numPreallocated;
-
-    // make sure we got the minimum guaranteed by OpenAL.
-    ENSURE(al_src_numPreallocated >= 16);
 }
 
 
 /**
- * release all sources on free list.
- * all sources must already have been released via al_src_free.
  * called from al_shutdown.
+ * all sources must already have been released via al_src_free.
  */
 static void al_src_shutdown()
 {
-    for(size_t i = 0; i < al_src_numPreallocated; i++)
-        ENSURE(al_srcs_allocationStates[i] == kAvailable);
-
-    AL_CHECK;
-    alDeleteSources((ALsizei)al_src_numPreallocated, al_srcs);
-    AL_CHECK;
-
-    al_src_numPreallocated = 0;
+    // (we no longer bother keeping a list of extant sources,
+    // because they will be freed at exit anyway.)
+    ENSURE(al_src_inUse == 0);
 }
 
 
+TIMER_ADD_CLIENT(tc_OpenAL_source);
+
 /**
  * try to allocate a source.
  *
- * @return whether a source was allocated (see al_srcs_allocationStates).
+ * @return whether a source was allocated.
  * @param al_src receives the new source name iff true is returned.
  */
 static bool al_src_alloc(ALuint& al_src)
 {
-    for(size_t i = 0; i < al_src_numPreallocated; i++)
-    {
-        if(cpu_CAS(&al_srcs_allocationStates[i], kAvailable, kInUse))
-        {
-            al_src = al_srcs[i];
-            return true;
-        }
-    }
+TIMER_ACCRUE(tc_OpenAL_source);
 
-    return false;   // no more to give
+    if((size_t)al_src_inUse >= al_src_maxNumToUse)
+        return false;   // allocated too many already
+    cpu_AtomicAdd(&al_src_inUse, +1);
+
+    AL_CHECK;
+    alGenSources(1, &al_src);
+    AL_CHECK;
+    return true;
 }
 
 
@@ -511 +473 @@
  */
 static void al_src_free(ALuint al_src)
 {
+TIMER_ACCRUE(tc_OpenAL_source);
     ENSURE(alIsSource(al_src));
 
-    const ALuint* pos = std::find(al_srcs, al_srcs+al_src_numPreallocated, al_src);
-    if(pos != al_srcs+al_src_numPreallocated)   // found it
-    {
-        const size_t i = pos - al_srcs;
-        ENSURE(cpu_CAS(&al_srcs_allocationStates[i], kInUse, kAvailable));
-    }
-    else
-        DEBUG_WARN_ERR(ERR::LOGIC); // al_src wasn't in al_srcs
+    cpu_AtomicAdd(&al_src_inUse, -1);
+
+    AL_CHECK;
+    alDeleteSources(1, &al_src);
+    AL_CHECK;
 }
 
 
@@ -528 +488 @@
  * set maximum number of voices to play simultaneously,
  * to reduce mixing cost on low-end systems.
  * this limit may be ignored if e.g. there's a stricter
- * implementation- defined ceiling anyway.
+ * implementation-defined ceiling anyway.
  *
  * @param limit max. number of sources
  * @return Status
  */
 Status snd_set_max_voices(size_t limit)
 {
-    // valid if cap is legit (less than what we allocated in al_src_init),
-    // or if al_src_init hasn't been called yet. note: we accept anything
-    // in the second case, as al_src_init will sanity-check al_src_cap.
-    if(!al_src_numPreallocated || limit < al_src_numPreallocated)
-    {
-        al_src_maxNumToUse = limit;
-        return INFO::OK;
-    }
-    // user is requesting a cap higher than what we actually allocated.
-    // that's fine (not an error), but we won't set the cap, since it
-    // determines how many sources may be returned.
-    // there's no return value to indicate this because the cap is
-    // precisely that - an upper limit only, we don't care if it can't be met.
-    else
-        return INFO::OK;
+    al_src_maxNumToUse = limit;
+    return INFO::OK;
 }