address comments

Author: robertwu1

apps/OboeTester/app/src/main/cpp/cpu/AudioWorkloadTest.cpp

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include "AudioWorkloadTest.h"
 
 AudioWorkloadTest::AudioWorkloadTest() : mStream(nullptr) {}
@@ -19,8 +35,6 @@ int32_t AudioWorkloadTest::open() {
 
     mFramesPerBurst = mStream->getFramesPerBurst();
     mSampleRate = mStream->getSampleRate();
-    mStream->setBufferSizeInFrames(mBufferSizeInBursts * mFramesPerBurst);
-    mBufferSizeInFrames = mStream->getBufferSizeInFrames();
     mPreviousXRunCount = 0;
     mXRunCount = 0;
 
@@ -39,8 +53,10 @@ int32_t AudioWorkloadTest::getBufferSizeInFrames() const {
     return mBufferSizeInFrames;
 }
 
-int32_t AudioWorkloadTest::start(int32_t numCallbacks, int32_t bufferSizeInBursts, int32_t numVoices, int32_t alternateNumVoices, int32_t alternatingPeriodMs, bool adpfEnabled, bool sineEnabled) {
-    mNumCallbacks = numCallbacks;
+int32_t AudioWorkloadTest::start(int32_t targetDurationMs, int32_t bufferSizeInBursts, int32_t numVoices,
+                                 int32_t alternateNumVoices, int32_t alternatingPeriodMs, bool adpfEnabled,
+                                 bool hearWorkload) {
+    mTargetDurationMs = targetDurationMs;
     mBufferSizeInBursts = bufferSizeInBursts;
     mNumVoices = numVoices;
     mAlternateNumVoices = alternateNumVoices;
@@ -51,8 +67,10 @@ int32_t AudioWorkloadTest::start(int32_t numCallbacks, int32_t bufferSizeInBurst
     mPreviousXRunCount = mXRunCount.load();
     mXRunCount = 0;
     mRunning = true;
-    mSineEnabled = sineEnabled;
+    mHearWorkload = hearWorkload;
     mStream->setPerformanceHintEnabled(adpfEnabled);
+    mStream->setBufferSizeInFrames(mBufferSizeInBursts * mFramesPerBurst);
+    mBufferSizeInFrames = mStream->getBufferSizeInFrames();
     mSynthWorkload = SynthWorkload((int) 0.2 * mSampleRate, (int) 0.3 * mSampleRate);
     oboe::Result result = mStream->start();
     if (result != oboe::Result::OK) {
@@ -83,11 +101,11 @@ int32_t AudioWorkloadTest::getCpuCount() {
     return sysconf(_SC_NPROCESSORS_CONF);
 }
 
-int32_t AudioWorkloadTest::getXRunCount() {
+int32_t AudioWorkloadTest::getXRunCount() const {
     return mXRunCount - mPreviousXRunCount;
 }
 
-int32_t AudioWorkloadTest::getCallbackCount() {
+int32_t AudioWorkloadTest::getCallbackCount() const {
     return mCallbackCount;
 }
 
@@ -122,12 +140,15 @@ std::vector<AudioWorkloadTest::CallbackStatus> AudioWorkloadTest::getCallbackSta
     return mCallbackStatistics;
 }
 
-oboe::DataCallbackResult AudioWorkloadTest::onAudioReady(oboe::AudioStream* audioStream, void* audioData, int32_t numFrames) {
-    int64_t beginTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+oboe::DataCallbackResult AudioWorkloadTest::onAudioReady(oboe::AudioStream* audioStream,
+                                                         void* audioData, int32_t numFrames) {
+    int64_t beginTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::high_resolution_clock::now().time_since_epoch()).count();
 
     int currentVoices = mNumVoices;
     if (mAlternatingPeriodMs > 0) {
-        int64_t timeMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+        int64_t timeMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::high_resolution_clock::now().time_since_epoch()).count();
         if (mStartTimeMs == 0) {
             mStartTimeMs = timeMs;
         }
@@ -136,15 +157,30 @@ oboe::DataCallbackResult AudioWorkloadTest::onAudioReady(oboe::AudioStream* audi
         }
     }
 
+    auto floatData = static_cast<float *>(audioData);
+    int channelCount = audioStream->getChannelCount();
+
+    // Fill buffer with a sine wave.
+    for (int i = 0; i < numFrames; i++) {
+        float value = sinf(mPhase) * 0.2f;
+        for (int j = 0; j < channelCount; j++) {
+            *floatData++ = value;
+        }
+        mPhase = mPhase + kPhaseIncrement;
+        // Wrap the phase around in a circle.
+        if (mPhase >= M_PI) mPhase = mPhase - 2.0f * M_PI;
+    }
+
     mSynthWorkload.onCallback(currentVoices);
     if (currentVoices > 0) {
-        // Render into the buffer or discard the synth voices.
-        float *buffer = (audioStream->getChannelCount() == 2 && mSineEnabled)
+        // Render synth workload into the buffer or discard the synth voices.
+        float *buffer = (audioStream->getChannelCount() == 2 && mHearWorkload)
                         ? static_cast<float *>(audioData) : nullptr;
         mSynthWorkload.renderStereo(buffer, numFrames);
     }
 
-    int64_t finishTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+    int64_t finishTimeNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::high_resolution_clock::now().time_since_epoch()).count();
 
     mXRunCount = audioStream->getXRunCount().value();
 
@@ -159,7 +195,10 @@ oboe::DataCallbackResult AudioWorkloadTest::onAudioReady(oboe::AudioStream* audi
     mCallbackCount++;
     mLastDurationNs = finishTimeNs - beginTimeNs;
 
-    if (mCallbackCount >= mNumCallbacks) {
+    int64_t currentTimeMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+
+    if (currentTimeMs - mStartTimeMs > mTargetDurationMs) {
         mRunning = false;
         stop();
         return oboe::DataCallbackResult::Stop;

apps/OboeTester/app/src/main/cpp/cpu/AudioWorkloadTest.h

@@ -28,52 +28,174 @@
 #include <unistd.h> // For CPU affinity
 #include "SynthWorkload.h"
 
+/**
+ * @class AudioWorkloadTest
+ * @brief A class designed to test audio workload performance using the Oboe library.
+ *
+ * This class sets up an audio stream, generates a synthetic audio load (sine wave and/or
+ * a more complex synth workload), and collects statistics about the audio callback performance,
+ * such as callback duration, XRun counts, and CPU usage.
+ */
 class AudioWorkloadTest : oboe::AudioStreamDataCallback {
 public:
+    /**
+     * @struct CallbackStatus
+     * @brief Structure to store statistics for each audio callback invocation.
+     */
     struct CallbackStatus {
-        int32_t numVoices;
-        int64_t beginTimeNs;
-        int64_t finishTimeNs;
-        int32_t xRunCount;
-        int32_t cpuIndex;
+        int32_t numVoices;      // Number of synthesizer voices active during this callback
+        int64_t beginTimeNs;    // Timestamp (nanoseconds) when the callback started
+        int64_t finishTimeNs;   // Timestamp (nanoseconds) when the callback finished
+        int32_t xRunCount;      // Cumulative XRun (underrun/overrun) count at this point
+        int32_t cpuIndex;       // CPU core index on which the callback executed
     };
 
+    /**
+     * @brief Constructor for AudioWorkloadTest.
+     * Initializes the audio stream pointer to nullptr.
+     */
     AudioWorkloadTest();
+
+    /**
+     * @brief Opens an audio stream with specified parameters.
+     * Configures the stream for low latency output.
+     * @return 0 on success, or a negative Oboe error code on failure.
+     */
     int32_t open();
+
+    /**
+     * @brief Gets the number of frames processed in a single audio callback burst.
+     * @return The number of frames per burst.
+     */
     int32_t getFramesPerBurst() const;
+
+    /**
+     * @brief Gets the sample rate of the audio stream.
+     * @return The sample rate in Hz.
+     */
     int32_t getSampleRate() const;
+
+    /**
+     * @brief Gets the current buffer size of the audio stream in frames.
+     * @return The buffer size in frames.
+     */
     int32_t getBufferSizeInFrames() const;
-    int32_t start(int32_t numCallbacks, int32_t bufferSizeInBursts, int32_t numVoices, int32_t alternateNumVoices, int32_t alternatingPeriodMs, bool adpfEnabled, bool sineEnabled);
+
+    /**
+     * @brief Starts the audio stream and the workload test.
+     * @param targetDurationMillis The desired duration of the test in milliseconds.
+     * @param bufferSizeInBursts The desired buffer size in terms of multiples of framesPerBurst.
+     * @param numVoices The primary number of synthesizer voices to simulate.
+     * @param alternateNumVoices An alternative number of voices for alternating workload.
+     * @param alternatingPeriodMs The period in milliseconds to alternate between numVoices and
+     * alternateNumVoices.
+     * @param adpfEnabled Whether to enable Adaptive Performance (ADPF) hints.
+     * @param hearWorkload If true, the synthesized audio will be audible; otherwise, it's processed
+     * silently.
+     * @return 0 on success, or a negative Oboe error code on failure.
+     */
+    int32_t start(int32_t targetDurationMillis, int32_t bufferSizeInBursts, int32_t numVoices,
+                  int32_t alternateNumVoices, int32_t alternatingPeriodMs, bool adpfEnabled,
+                  bool hearWorkload);
+
+    /**
+     * @brief Gets the number of available CPU cores on the system.
+     * @return The number of CPU cores.
+     */
     static int32_t getCpuCount();
+
+    /**
+     * @brief Sets the CPU affinity for the current thread (intended for the audio callback
+     * thread).
+     * @param mask A bitmask specifying the allowed CPU cores.
+     * @return 0 on success, -1 on failure.
+     */
     static int32_t setCpuAffinityForCallback(uint32_t mask);
-    int32_t getXRunCount();
-    int32_t getCallbackCount();
+
+    /**
+     * @brief Gets the number of XRuns (underruns/overruns) that occurred during the last test run.
+     * @return The XRun count.
+     */
+    int32_t getXRunCount() const;
+
+    /**
+     * @brief Gets the total number of audio callbacks invoked during the last test run.
+     * @return The callback count.
+     */
+    int32_t getCallbackCount() const;
+
+    /**
+     * @brief Gets the duration of the last audio callback in nanoseconds.
+     * @return The duration in nanoseconds.
+     */
     int64_t getLastDurationNs();
+
+    /**
+     * @brief Checks if the audio workload test is currently running.
+     * @return True if running, false otherwise.
+     */
     bool isRunning();
+
+    /**
+     * @brief Stops the audio stream.
+     * @return 0 on success, or a negative Oboe error code on failure.
+     */
     int32_t stop();
+
+    /**
+     * @brief Closes the audio stream and releases resources.
+     * @return 0 on success.
+     */
     int32_t close();
+
+    /**
+     * @brief Retrieves the collected statistics for each audio callback.
+     * @return A vector of CallbackStatus structures.
+     */
     std::vector<CallbackStatus> getCallbackStatistics();
-    oboe::DataCallbackResult onAudioReady(oboe::AudioStream* audioStream, void* audioData, int32_t numFrames) override;
+
+    /**
+     * @brief The Oboe audio callback function.
+     * This function is called by the Oboe library when it needs more audio data.
+     * It generates audio, performs workload simulation, and collects statistics.
+     * @param audioStream Pointer to the Oboe audio stream.
+     * @param audioData Pointer to the buffer where audio data should be written.
+     * @param numFrames The number of audio frames to be filled.
+     * @return oboe::DataCallbackResult::Continue to continue streaming, or
+     * oboe::DataCallbackResult::Stop to stop.
+     */
+    oboe::DataCallbackResult onAudioReady(oboe::AudioStream* audioStream, void* audioData,
+                                          int32_t numFrames) override;
 
 private:
-    oboe::AudioStream* mStream;
+    // Member variables
+    oboe::AudioStream* mStream;              // Pointer to the Oboe audio stream instance
+
+    // Atomic variables for thread-safe access from audio callback and other threads
     std::atomic<int32_t> mFramesPerBurst{0};
     std::atomic<int32_t> mSampleRate{0};
     std::atomic<int32_t> mCallbackCount{0};
     std::atomic<int32_t> mPreviousXRunCount{0};
     std::atomic<int32_t> mXRunCount{0};
-    std::atomic<int32_t> mNumCallbacks{0};
+    std::atomic<int32_t> mTargetDurationMs{0};
     std::atomic<int32_t> mBufferSizeInBursts{0};
     std::atomic<int32_t> mBufferSizeInFrames{0};
     std::atomic<int32_t> mNumVoices{0};
     std::atomic<int32_t> mAlternateNumVoices{0};
     std::atomic<int32_t> mAlternatingPeriodMs{0};
     std::atomic<int64_t> mLastDurationNs{0};
     std::atomic<int64_t> mStartTimeMs{0};
-    std::atomic<bool> mSineEnabled{false};
+    std::atomic<bool> mHearWorkload{false};
+
     std::vector<CallbackStatus> mCallbackStatistics;
     std::atomic<bool> mRunning{false};
-    SynthWorkload mSynthWorkload;
+
+    // Sine wave generation parameters
+    std::atomic<float> mPhase{0.0f};           // Current phase of the sine wave oscillator
+    // Phase increment for a 440 Hz sine wave at a 48000 Hz sample rate
+    static constexpr float kPhaseIncrement = 2.0f * (float) M_PI * 440.0f / 48000.0f;
+
+    SynthWorkload mSynthWorkload;              // Instance of the synthetic workload generator
 };
 
 #endif // AUDIO_WORKLOAD_TEST_H