Allow sharing of the Trace API for Perfetto (#2210)

Use Singleton design pattern and early initialization in Trace API

Add a "Workload" trace for OboeTester CPU LOAD test

Author: philburk

apps/OboeTester/app/src/main/cpp/NativeAudioContext.h

@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "common/OboeDebug.h"
+#include "common/Trace.h"
 #include "oboe/Oboe.h"
 
 #include "aaudio/AAudioExtensions.h"
@@ -173,6 +174,10 @@ class ActivityContext {
 
     void setWorkload(int32_t workload) {
         oboeCallbackProxy.setWorkload(workload);
+        bool traceEnabled = oboe::Trace::getInstance().isEnabled();
+        if (traceEnabled) {
+            oboe::Trace::getInstance().setCounter("Workload", workload);
+        }
     }
 
     void setHearWorkload(bool enabled) {

src/common/AdpfWrapper.cpp

@@ -68,8 +68,6 @@ static int loadAphFunctions() {
 
     gAPerformanceHintBindingInitialized = true;
 
-    Trace::initialize();
-
     return 0;
 }
 
@@ -101,12 +99,17 @@ int AdpfWrapper::open(pid_t threadId,
 void AdpfWrapper::reportActualDuration(int64_t actualDurationNanos) {
     //LOGD("ADPF Oboe %s(dur=%lld)", __func__, (long long)actualDurationNanos);
     std::lock_guard<std::mutex> lock(mLock);
-    Trace::beginSection("reportActualDuration");
-    Trace::setCounter("actualDurationNanos", actualDurationNanos);
     if (mHintSession != nullptr) {
+        bool traceEnabled = Trace::getInstance().isEnabled();
+        if (traceEnabled) {
+            Trace::getInstance().beginSection("reportActualDuration");
+            Trace::getInstance().setCounter("actualDurationNanos", actualDurationNanos);
+        }
         gAPH_reportActualWorkDurationFn(mHintSession, actualDurationNanos);
+        if (traceEnabled) {
+            Trace::getInstance().endSection();
+        }
     }
-    Trace::endSection();
 }
 
 void AdpfWrapper::close() {

src/common/StabilizedCallback.cpp

@@ -23,8 +23,7 @@ constexpr float kPercentageOfCallbackToUse = 0.8;
 
 using namespace oboe;
 
-StabilizedCallback::StabilizedCallback(AudioStreamCallback *callback) : mCallback(callback){
-    Trace::initialize();
+StabilizedCallback::StabilizedCallback(AudioStreamCallback *callback) : mCallback(callback) {
 }
 
 /**
@@ -64,16 +63,17 @@ StabilizedCallback::onAudioReady(AudioStream *oboeStream, void *audioData, int32
     int64_t targetDurationNanos = static_cast<int64_t>(
             (numFramesAsNanos * kPercentageOfCallbackToUse) - lateStartNanos);
 
-    Trace::beginSection("Actual load");
+    bool traceEnabled = Trace::getInstance().isEnabled();
+    if (traceEnabled) Trace::getInstance().beginSection("Actual load");
     DataCallbackResult result = mCallback->onAudioReady(oboeStream, audioData, numFrames);
-    Trace::endSection();
+    if (traceEnabled) Trace::getInstance().endSection();
 
     int64_t executionDurationNanos = AudioClock::getNanoseconds() - startTimeNanos;
     int64_t stabilizingLoadDurationNanos = targetDurationNanos - executionDurationNanos;
 
-    Trace::beginSection("Stabilized load for %lldns", stabilizingLoadDurationNanos);
+    if (traceEnabled) Trace::getInstance().beginSection("Stabilized load for %lldns", stabilizingLoadDurationNanos);
     generateLoad(stabilizingLoadDurationNanos);
-    Trace::endSection();
+    if (traceEnabled) Trace::getInstance().endSection();
 
     // Wraparound: At 48000 frames per second mFrameCount wraparound will occur after 6m years,
     // significantly longer than the average lifetime of an Android phone.

src/common/Trace.cpp

@@ -21,17 +21,6 @@
 
 using namespace oboe;
 
-static char buffer[256];
-
-// Tracing functions
-static void *(*ATrace_beginSection)(const char *sectionName);
-
-static void *(*ATrace_endSection)();
-
-static void *(*ATrace_setCounter)(const char *counterName, int64_t counterValue);
-
-static bool *(*ATrace_isEnabled)(void);
-
 typedef void *(*fp_ATrace_beginSection)(const char *sectionName);
 
 typedef void *(*fp_ATrace_endSection)();
@@ -40,65 +29,65 @@ typedef void *(*fp_ATrace_setCounter)(const char *counterName, int64_t counterVa
 
 typedef bool *(*fp_ATrace_isEnabled)(void);
 
-bool Trace::mIsTracingEnabled = false;
-bool Trace::mIsSetCounterSupported = false;
-bool Trace::mHasErrorBeenShown = false;
+bool Trace::isEnabled() const {
+    return ATrace_isEnabled != nullptr && ATrace_isEnabled();
+}
 
-void Trace::beginSection(const char *format, ...){
-    if (mIsTracingEnabled) {
-        va_list va;
-        va_start(va, format);
-        vsprintf(buffer, format, va);
-        ATrace_beginSection(buffer);
-        va_end(va);
-    } else if (!mHasErrorBeenShown) {
-        LOGE("Tracing is either not initialized (call Trace::initialize()) "
-             "or not supported on this device");
-        mHasErrorBeenShown = true;
-    }
+void Trace::beginSection(const char *format, ...) {
+    char buffer[256];
+    va_list va;
+    va_start(va, format);
+    vsprintf(buffer, format, va);
+    ATrace_beginSection(buffer);
+    va_end(va);
 }
 
-void Trace::endSection() {
-    if (mIsTracingEnabled) {
-        ATrace_endSection();
-    }
+void Trace::endSection() const {
+    ATrace_endSection();
 }
 
-void Trace::setCounter(const char *counterName, int64_t counterValue) {
-    if (mIsSetCounterSupported) {
-        ATrace_setCounter(counterName, counterValue);
-    }
+void Trace::setCounter(const char *counterName, int64_t counterValue) const {
+    ATrace_setCounter(counterName, counterValue);
 }
 
-void Trace::initialize() {
-    //LOGE("Trace::initialize");
+Trace::Trace() {
     // Using dlsym allows us to use tracing on API 21+ without needing android/trace.h which wasn't
     // published until API 23
     void *lib = dlopen("libandroid.so", RTLD_NOW | RTLD_LOCAL);
+    LOGD("Trace():  dlopen(%s) returned %p", "libandroid.so", lib);
     if (lib == nullptr) {
-        LOGE("Could not open libandroid.so to dynamically load tracing symbols");
+        LOGE("Trace() could not open libandroid.so to dynamically load tracing symbols");
     } else {
         ATrace_beginSection =
-                reinterpret_cast<fp_ATrace_beginSection >(
+                reinterpret_cast<fp_ATrace_beginSection>(
                         dlsym(lib, "ATrace_beginSection"));
+        if (ATrace_beginSection == nullptr) {
+            LOGE("Trace::beginSection() not supported");
+            return;
+        }
+
         ATrace_endSection =
-                reinterpret_cast<fp_ATrace_endSection >(
+                reinterpret_cast<fp_ATrace_endSection>(
                         dlsym(lib, "ATrace_endSection"));
+        if (ATrace_endSection == nullptr) {
+            LOGE("Trace::endSection() not supported");
+            return;
+        }
+
         ATrace_setCounter =
-                reinterpret_cast<fp_ATrace_setCounter >(
+                reinterpret_cast<fp_ATrace_setCounter>(
                         dlsym(lib, "ATrace_setCounter"));
+        if (ATrace_setCounter == nullptr) {
+            LOGE("Trace::setCounter() not supported");
+            return;
+        }
+
+        // If any of the previous functions are null then ATrace_isEnabled will be null.
         ATrace_isEnabled =
-                reinterpret_cast<fp_ATrace_isEnabled >(
+                reinterpret_cast<fp_ATrace_isEnabled>(
                         dlsym(lib, "ATrace_isEnabled"));
-
-        if (ATrace_beginSection != nullptr && ATrace_endSection != nullptr
-                && ATrace_isEnabled != nullptr && ATrace_isEnabled()) {
-            mIsTracingEnabled = true;
-            if (ATrace_setCounter != nullptr) {
-                mIsSetCounterSupported = true;
-            } else {
-                LOGE("setCounter not supported");
-            }
+        if (ATrace_isEnabled == nullptr) {
+            LOGE("Trace::isEnabled() not supported");
         }
     }
 }

src/common/Trace.h

@@ -27,18 +27,45 @@ namespace oboe {
 class Trace {
 
 public:
-    static void beginSection(const char *format, ...);
+    static Trace &getInstance() {
+        static Trace instance;
+        return instance;
+    }
 
-    static void endSection();
+    /**
+     * @return true if Perfetto tracing is enabled.
+     */
+    bool isEnabled() const;
 
-    static void setCounter(const char *counterName, int64_t counterValue);
+    /**
+     * Only call this function if isEnabled() returns true.
+     * @param format
+     * @param ...
+     */
+    void beginSection(const char *format, ...);
 
-    static void initialize();
+    /**
+     * Only call this function if isEnabled() returns true.
+     */
+    void endSection() const;
+
+    /**
+     * Only call this function if isEnabled() returns true.
+     * @param counterName human readable name
+     * @param counterValue value to log in trace
+     */
+    void setCounter(const char *counterName, int64_t counterValue) const;
 
 private:
-    static bool mIsTracingEnabled;
-    static bool mIsSetCounterSupported;
-    static bool mHasErrorBeenShown;
+    Trace();
+// Tracing functions
+    void *(*ATrace_beginSection)(const char *sectionName) = nullptr;
+
+    void *(*ATrace_endSection)() = nullptr;
+
+    void *(*ATrace_setCounter)(const char *counterName, int64_t counterValue) = nullptr;
+
+    bool *(*ATrace_isEnabled)(void) = nullptr;
 };
 
 }