Covert gRandomGenerator into a unique_ptr. Having a static object of type LLRandFlagFib2281 needs a lot of space in the TLB, which is usually fine. Unless libcef gets loaded...

CEF is compiled with static TLS/TLS model initial-exec and then having gRandomGenerator allocation so much space in the TLB will exhaust the available space and CEF cannot be loaded.

Author: Nicky-D

indra/llcommon/llrand.cpp

@@ -58,9 +58,26 @@
  * to restore uniform distribution.
  */
 
-// gRandomGenerator is a stateful static object, which is therefore not
+// pRandomGenerator is a stateful static object, which is therefore not
 // inherently thread-safe.
-static thread_local LLRandLagFib2281 gRandomGenerator(LLUUID::getRandomSeed());
+//We use a pointer to not construct a huge object in the TLS space, sadly this is necessary
+// due to libcef.so on Linux being compiled with TLS model initial-exec (resulting in
+// FLAG STATIC_TLS, see readelf libcef.so). CEFs own TLS objects + LLRandLagFib2281 then will exhaust the
+// available TLS space, causing media failure.
+
+static thread_local std::unique_ptr< LLRandLagFib2281 > pRandomGenerator = nullptr;
+
+namespace {
+    F64 ll_internal_get_rand()
+    {
+        if( !pRandomGenerator )
+        {
+            pRandomGenerator.reset(new LLRandLagFib2281(LLUUID::getRandomSeed( ) ));
+        }
+
+        return(*pRandomGenerator)();
+    }
+}
 
 // no default implementation, only specific F64 and F32 specializations
 template <typename REAL>
@@ -73,7 +90,7 @@ inline F64 ll_internal_random<F64>()
     // CPUs (or at least multi-threaded processes) seem to
     // occasionally give an obviously incorrect random number -- like
     // 5^15 or something. Sooooo, clamp it as described above.
-    F64 rv{ gRandomGenerator() };
+    F64 rv{ ll_internal_get_rand() };
     if(!((rv >= 0.0) && (rv < 1.0))) return fmod(rv, 1.0);
     return rv;
 }
@@ -85,7 +102,7 @@ inline F32 ll_internal_random<F32>()
     // Per Monty, it's important to clamp using the correct fmodf() rather
     // than expanding to F64 for fmod() and then truncating back to F32. Prior
     // to this change, we were getting sporadic ll_frand() == 1.0 results.
-    F32 rv{ narrow<F64>(gRandomGenerator()) };
+    F32 rv{ narrow<F64>(ll_internal_get_rand()) };
     if(!((rv >= 0.0f) && (rv < 1.0f))) return fmodf(rv, 1.0f);
     return rv;
 }