Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2a457b61 authored by Tej Singh's avatar Tej Singh
Browse files

Update sf stats puller for API feedback 

Test: statsd_testdrive 10062
Test: statsd_testdrive 10063
Test: atest libsurfaceflinger_unittest
Change-Id: Icd2998cf56445d4a9742479340a17cfcca4b11f1
parent 933e81b5

services/surfaceflinger/TimeStats/TimeStats.cpp

+11 −10
Original line number Diff line number Diff line
@@ -37,10 +37,11 @@ namespace android { 


namespace impl {



status_pull_atom_return_t TimeStats::pullAtomCallback(int32_t atom_tag,

                                                      pulled_stats_event_list* data, void* cookie) {

AStatsManager_PullAtomCallbackReturn TimeStats::pullAtomCallback(int32_t atom_tag,

                                                                 AStatsEventList* data,

                                                                 void* cookie) {

    impl::TimeStats* timeStats = reinterpret_cast<impl::TimeStats*>(cookie);

    status_pull_atom_return_t result = STATS_PULL_SKIP;

    AStatsManager_PullAtomCallbackReturn result = AStatsManager_PULL_SKIP;

    if (atom_tag == android::util::SURFACEFLINGER_STATS_GLOBAL_INFO) {

        result = timeStats->populateGlobalAtom(data);

    } else if (atom_tag == android::util::SURFACEFLINGER_STATS_LAYER_INFO) {
@@ -54,15 +55,15 @@ status_pull_atom_return_t TimeStats::pullAtomCallback(int32_t atom_tag, 
    return result;

}



status_pull_atom_return_t TimeStats::populateGlobalAtom(pulled_stats_event_list* data) {

AStatsManager_PullAtomCallbackReturn TimeStats::populateGlobalAtom(AStatsEventList* data) {

    std::lock_guard<std::mutex> lock(mMutex);



    if (mTimeStats.statsStart == 0) {

        return STATS_PULL_SKIP;

        return AStatsManager_PULL_SKIP;

    }

    flushPowerTimeLocked();



    struct stats_event* event = mStatsDelegate->addStatsEventToPullData(data);

    AStatsEvent* event = mStatsDelegate->addStatsEventToPullData(data);

    mStatsDelegate->statsEventSetAtomId(event, android::util::SURFACEFLINGER_STATS_GLOBAL_INFO);

    mStatsDelegate->statsEventWriteInt64(event, mTimeStats.totalFrames);

    mStatsDelegate->statsEventWriteInt64(event, mTimeStats.missedFrames);
@@ -72,7 +73,7 @@ status_pull_atom_return_t TimeStats::populateGlobalAtom(pulled_stats_event_list* 
    mStatsDelegate->statsEventBuild(event);

    clearGlobalLocked();



    return STATS_PULL_SUCCESS;

    return AStatsManager_PULL_SUCCESS;

}



namespace {
@@ -110,7 +111,7 @@ std::string histogramToProtoByteString(const std::unordered_map<int32_t, int32_t 
}

} // namespace



status_pull_atom_return_t TimeStats::populateLayerAtom(pulled_stats_event_list* data) {

AStatsManager_PullAtomCallbackReturn TimeStats::populateLayerAtom(AStatsEventList* data) {

    std::lock_guard<std::mutex> lock(mMutex);



    std::vector<TimeStatsHelper::TimeStatsLayer const*> dumpStats;
@@ -129,7 +130,7 @@ status_pull_atom_return_t TimeStats::populateLayerAtom(pulled_stats_event_list* 
    }



    for (const auto& layer : dumpStats) {

        struct stats_event* event = mStatsDelegate->addStatsEventToPullData(data);

        AStatsEvent* event = mStatsDelegate->addStatsEventToPullData(data);

        mStatsDelegate->statsEventSetAtomId(event, android::util::SURFACEFLINGER_STATS_LAYER_INFO);

        mStatsDelegate->statsEventWriteString8(event, layer->layerName.c_str());

        mStatsDelegate->statsEventWriteInt64(event, layer->totalFrames);
@@ -151,7 +152,7 @@ status_pull_atom_return_t TimeStats::populateLayerAtom(pulled_stats_event_list* 
    }

    clearLayersLocked();



    return STATS_PULL_SUCCESS;

    return AStatsManager_PULL_SUCCESS;

}



TimeStats::TimeStats() : TimeStats(nullptr, std::nullopt, std::nullopt) {}

services/surfaceflinger/TimeStats/TimeStats.h

+21 −19
Original line number Diff line number Diff line
@@ -159,37 +159,38 @@ public: 
    class StatsEventDelegate {

    public:

        virtual ~StatsEventDelegate() = default;

        virtual struct stats_event* addStatsEventToPullData(pulled_stats_event_list* data) {

            return add_stats_event_to_pull_data(data);

        virtual AStatsEvent* addStatsEventToPullData(AStatsEventList* data) {

            return AStatsEventList_addStatsEvent(data);

        }

        virtual void registerStatsPullAtomCallback(int32_t atom_tag,

                                                   stats_pull_atom_callback_t callback,

                                                   pull_atom_metadata* metadata, void* cookie) {

            return register_stats_pull_atom_callback(atom_tag, callback, metadata, cookie);

                                                   AStatsManager_PullAtomCallback callback,

                                                   AStatsManager_PullAtomMetadata* metadata,

                                                   void* cookie) {

            return AStatsManager_registerPullAtomCallback(atom_tag, callback, metadata, cookie);

        }



        virtual void unregisterStatsPullAtomCallback(int32_t atom_tag) {

            return unregister_stats_pull_atom_callback(atom_tag);

            return AStatsManager_unregisterPullAtomCallback(atom_tag);

        }



        virtual void statsEventSetAtomId(struct stats_event* event, uint32_t atom_id) {

            return stats_event_set_atom_id(event, atom_id);

        virtual void statsEventSetAtomId(AStatsEvent* event, uint32_t atom_id) {

            return AStatsEvent_setAtomId(event, atom_id);

        }



        virtual void statsEventWriteInt64(struct stats_event* event, int64_t field) {

            return stats_event_write_int64(event, field);

        virtual void statsEventWriteInt64(AStatsEvent* event, int64_t field) {

            return AStatsEvent_writeInt64(event, field);

        }



        virtual void statsEventWriteString8(struct stats_event* event, const char* field) {

            return stats_event_write_string8(event, field);

        virtual void statsEventWriteString8(AStatsEvent* event, const char* field) {

            return AStatsEvent_writeString(event, field);

        }



        virtual void statsEventWriteByteArray(struct stats_event* event, const uint8_t* buf,

        virtual void statsEventWriteByteArray(AStatsEvent* event, const uint8_t* buf,

                                              size_t numBytes) {

            return stats_event_write_byte_array(event, buf, numBytes);

            return AStatsEvent_writeByteArray(event, buf, numBytes);

        }



        virtual void statsEventBuild(struct stats_event* event) { return stats_event_build(event); }

        virtual void statsEventBuild(AStatsEvent* event) { return AStatsEvent_build(event); }

    };

    // For testing only for injecting custom dependencies.

    TimeStats(std::unique_ptr<StatsEventDelegate> statsDelegate,
@@ -238,10 +239,11 @@ public: 
    static const size_t MAX_NUM_TIME_RECORDS = 64;



private:

    static status_pull_atom_return_t pullAtomCallback(int32_t atom_tag,

                                                      pulled_stats_event_list* data, void* cookie);

    status_pull_atom_return_t populateGlobalAtom(pulled_stats_event_list* data);

    status_pull_atom_return_t populateLayerAtom(pulled_stats_event_list* data);

    static AStatsManager_PullAtomCallbackReturn pullAtomCallback(int32_t atom_tag,

                                                                 AStatsEventList* data,

                                                                 void* cookie);

    AStatsManager_PullAtomCallbackReturn populateGlobalAtom(AStatsEventList* data);

    AStatsManager_PullAtomCallbackReturn populateLayerAtom(AStatsEventList* data);

    bool recordReadyLocked(int32_t layerId, TimeRecord* timeRecord);

    void flushAvailableRecordsToStatsLocked(int32_t layerId);

    void flushPowerTimeLocked();

services/surfaceflinger/tests/unittests/TimeStatsTest.cpp

+18 −17
Original line number Diff line number Diff line
@@ -148,30 +148,31 @@ public: 
        FakeStatsEventDelegate() = default;

        ~FakeStatsEventDelegate() override = default;



        struct stats_event* addStatsEventToPullData(pulled_stats_event_list*) override {

        struct AStatsEvent* addStatsEventToPullData(AStatsEventList*) override {

            return mEvent;

        }

        void registerStatsPullAtomCallback(int32_t atom_tag, stats_pull_atom_callback_t callback,

                                           pull_atom_metadata*, void* cookie) override {

        void registerStatsPullAtomCallback(int32_t atom_tag,

                                           AStatsManager_PullAtomCallback callback,

                                           AStatsManager_PullAtomMetadata*, void* cookie) override {

            mAtomTags.push_back(atom_tag);

            mCallback = callback;

            mCookie = cookie;

        }



        status_pull_atom_return_t makePullAtomCallback(int32_t atom_tag, void* cookie) {

        AStatsManager_PullAtomCallbackReturn makePullAtomCallback(int32_t atom_tag, void* cookie) {

            return (*mCallback)(atom_tag, nullptr, cookie);

        }



        MOCK_METHOD1(unregisterStatsPullAtomCallback, void(int32_t));

        MOCK_METHOD2(statsEventSetAtomId, void(struct stats_event*, uint32_t));

        MOCK_METHOD2(statsEventWriteInt64, void(struct stats_event*, int64_t));

        MOCK_METHOD2(statsEventWriteString8, void(struct stats_event*, const char*));

        MOCK_METHOD3(statsEventWriteByteArray, void(struct stats_event*, const uint8_t*, size_t));

        MOCK_METHOD1(statsEventBuild, void(struct stats_event*));

        MOCK_METHOD2(statsEventSetAtomId, void(AStatsEvent*, uint32_t));

        MOCK_METHOD2(statsEventWriteInt64, void(AStatsEvent*, int64_t));

        MOCK_METHOD2(statsEventWriteString8, void(AStatsEvent*, const char*));

        MOCK_METHOD3(statsEventWriteByteArray, void(AStatsEvent*, const uint8_t*, size_t));

        MOCK_METHOD1(statsEventBuild, void(AStatsEvent*));



        struct stats_event* mEvent = stats_event_obtain();

        AStatsEvent* mEvent = AStatsEvent_obtain();

        std::vector<int32_t> mAtomTags;

        stats_pull_atom_callback_t mCallback = nullptr;

        AStatsManager_PullAtomCallback mCallback = nullptr;

        void* mCookie = nullptr;

    };

    FakeStatsEventDelegate* mDelegate = new FakeStatsEventDelegate;
@@ -787,7 +788,7 @@ TEST_F(TimeStatsTest, globalStatsCallback) { 
        EXPECT_CALL(*mDelegate, statsEventWriteInt64(mDelegate->mEvent, 2));

        EXPECT_CALL(*mDelegate, statsEventBuild(mDelegate->mEvent));

    }

    EXPECT_EQ(STATS_PULL_SUCCESS,

    EXPECT_EQ(AStatsManager_PULL_SUCCESS,

              mDelegate->makePullAtomCallback(android::util::SURFACEFLINGER_STATS_GLOBAL_INFO,

                                              mDelegate->mCookie));
@@ -908,7 +909,7 @@ TEST_F(TimeStatsTest, layerStatsCallback_pullsAllHistogramsAndClears) { 
                                             expectedPostToAcquire.size()));

        EXPECT_CALL(*mDelegate, statsEventBuild(mDelegate->mEvent));

    }

    EXPECT_EQ(STATS_PULL_SUCCESS,

    EXPECT_EQ(AStatsManager_PULL_SUCCESS,

              mDelegate->makePullAtomCallback(android::util::SURFACEFLINGER_STATS_LAYER_INFO,

                                              mDelegate->mCookie));
@@ -942,7 +943,7 @@ TEST_F(TimeStatsTest, layerStatsCallback_pullsMultipleLayers) { 
                statsEventWriteString8(mDelegate->mEvent, StrEq(genLayerName(LAYER_ID_0).c_str())));

    EXPECT_CALL(*mDelegate,

                statsEventWriteString8(mDelegate->mEvent, StrEq(genLayerName(LAYER_ID_1).c_str())));

    EXPECT_EQ(STATS_PULL_SUCCESS,

    EXPECT_EQ(AStatsManager_PULL_SUCCESS,

              mDelegate->makePullAtomCallback(android::util::SURFACEFLINGER_STATS_LAYER_INFO,

                                              mDelegate->mCookie));

}
@@ -983,7 +984,7 @@ TEST_F(TimeStatsTest, layerStatsCallback_pullsMultipleBuckets) { 
        EXPECT_CALL(*mDelegate, statsEventWriteByteArray(mDelegate->mEvent, _, _))

                .Times(AnyNumber());

    }

    EXPECT_EQ(STATS_PULL_SUCCESS,

    EXPECT_EQ(AStatsManager_PULL_SUCCESS,

              mDelegate->makePullAtomCallback(android::util::SURFACEFLINGER_STATS_LAYER_INFO,

                                              mDelegate->mCookie));

}
@@ -1023,7 +1024,7 @@ TEST_F(TimeStatsTest, layerStatsCallback_limitsHistogramBuckets) { 
        EXPECT_CALL(*mDelegate, statsEventWriteByteArray(mDelegate->mEvent, _, _))

                .Times(AnyNumber());

    }

    EXPECT_EQ(STATS_PULL_SUCCESS,

    EXPECT_EQ(AStatsManager_PULL_SUCCESS,

              mDelegate->makePullAtomCallback(android::util::SURFACEFLINGER_STATS_LAYER_INFO,

                                              mDelegate->mCookie));

}
@@ -1055,7 +1056,7 @@ TEST_F(TimeStatsTest, layerStatsCallback_limitsLayers) { 
            .Times(1);

    EXPECT_CALL(*mDelegate,

                statsEventWriteString8(mDelegate->mEvent, StrEq(genLayerName(LAYER_ID_1).c_str())));

    EXPECT_EQ(STATS_PULL_SUCCESS,

    EXPECT_EQ(AStatsManager_PULL_SUCCESS,

              mDelegate->makePullAtomCallback(android::util::SURFACEFLINGER_STATS_LAYER_INFO,

                                              mDelegate->mCookie));

}