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

Commit 0dac1caf authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 7478986 from 769add28 to sc-d1-release 

Change-Id: I4072f5f5971b6d2b41fcdc72f256719fe1e0a4cb
parents c56d1853 769add28

cmds/installd/run_dex2oat.cpp

+6 −0
Original line number Diff line number Diff line
@@ -324,6 +324,12 @@ void RunDex2Oat::PrepareCompilerRuntimeAndPerfConfigFlags(bool post_bootcomplete 


    AddRuntimeArg(MapPropertyToArg("dalvik.vm.dex2oat-Xms", "-Xms%s"));

    AddRuntimeArg(MapPropertyToArg("dalvik.vm.dex2oat-Xmx", "-Xmx%s"));



    // Enable compiling dex files in isolation on low ram devices.

    // It takes longer but reduces the memory footprint.

    if (GetBoolProperty("ro.config.low_ram", false)) {

      AddArg("--compile-individually");

    }

}



void RunDex2Oat::Exec(int exit_code) {

libs/gui/BLASTBufferQueue.cpp

+15 −10
Original line number Diff line number Diff line
@@ -151,6 +151,7 @@ BLASTBufferQueue::BLASTBufferQueue(const std::string& name, const sp<SurfaceCont 
                                                      1, false);

    static int32_t id = 0;

    auto consumerName = mName + "(BLAST Consumer)" + std::to_string(id);

    mPendingBufferTrace = "PendingBuffer - " + mName + "BLAST#" + std::to_string(id);

    id++;

    mBufferItemConsumer->setName(String8(consumerName.c_str()));

    mBufferItemConsumer->setFrameAvailableListener(this);
@@ -168,7 +169,6 @@ BLASTBufferQueue::BLASTBufferQueue(const std::string& name, const sp<SurfaceCont 
          .setFlags(surface, layer_state_t::eEnableBackpressure,

                    layer_state_t::eEnableBackpressure)

          .apply();



    mNumAcquired = 0;

    mNumFrameAvailable = 0;

}
@@ -259,6 +259,9 @@ void BLASTBufferQueue::transactionCallback(nsecs_t /*latchTime*/, const sp<Fence 


                mTransformHint = stat.transformHint;

                mBufferItemConsumer->setTransformHint(mTransformHint);

                // Update frametime stamps if the frame was latched and presented, indicated by a

                // valid latch time.

                if (stat.latchTime > 0) {

                    mBufferItemConsumer

                            ->updateFrameTimestamps(stat.frameEventStats.frameNumber,

                                                    stat.frameEventStats.refreshStartTime,
@@ -267,7 +270,7 @@ void BLASTBufferQueue::transactionCallback(nsecs_t /*latchTime*/, const sp<Fence 
                                                    stat.frameEventStats.compositorTiming,

                                                    stat.latchTime,

                                                    stat.frameEventStats.dequeueReadyTime);



                }

                currFrameNumber = stat.frameEventStats.frameNumber;



                if (mTransactionCompleteCallback &&
@@ -361,6 +364,7 @@ void BLASTBufferQueue::releaseBufferCallback(uint64_t graphicBufferId, 
    ATRACE_INT("PendingRelease", mPendingRelease.size());



    mNumAcquired--;

    ATRACE_INT(mPendingBufferTrace.c_str(), mNumFrameAvailable + mNumAcquired);

    processNextBufferLocked(false /* useNextTransaction */);

    mCallbackCV.notify_all();

}
@@ -529,6 +533,7 @@ void BLASTBufferQueue::onFrameAvailable(const BufferItem& item) { 
    }

    // add to shadow queue

    mNumFrameAvailable++;

    ATRACE_INT(mPendingBufferTrace.c_str(), mNumFrameAvailable + mNumAcquired);



    BQA_LOGV("onFrameAvailable framenumber=%" PRIu64 " nextTransactionSet=%s", item.mFrameNumber,

             toString(nextTransactionSet));

libs/gui/include/gui/BLASTBufferQueue.h

+1 −0
Original line number Diff line number Diff line
@@ -125,6 +125,7 @@ private: 
    static PixelFormat convertBufferFormat(PixelFormat& format);



    std::string mName;

    std::string mPendingBufferTrace;

    sp<SurfaceControl> mSurfaceControl;



    std::mutex mMutex;

libs/gui/include/gui/FrameTimestamps.h

+1 −0
Original line number Diff line number Diff line
@@ -131,6 +131,7 @@ public: 
    // Public for testing.

    static nsecs_t snapToNextTick(

            nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval);

    nsecs_t getReportedCompositeDeadline() const { return mCompositorTiming.deadline; };



    nsecs_t getNextCompositeDeadline(const nsecs_t now) const;

    nsecs_t getCompositeInterval() const { return mCompositorTiming.interval; }

libs/gui/tests/BLASTBufferQueue_test.cpp

+76 −15
Original line number Diff line number Diff line
@@ -948,21 +948,22 @@ TEST_F(BLASTBufferQueueTransformTest, setTransform_ROT_270) { 
class BLASTFrameEventHistoryTest : public BLASTBufferQueueTest {

public:

    void setUpAndQueueBuffer(const sp<IGraphicBufferProducer>& igbProducer,

                             nsecs_t* requestedPresentTime, nsecs_t* postedTime,

                             nsecs_t* outRequestedPresentTime, nsecs_t* postedTime,

                             IGraphicBufferProducer::QueueBufferOutput* qbOutput,

                             bool getFrameTimestamps, nsecs_t requestedPresentTimeDelay = 0) {

                             bool getFrameTimestamps, nsecs_t requestedPresentTime = systemTime()) {

        int slot;

        sp<Fence> fence;

        sp<GraphicBuffer> buf;

        auto ret = igbProducer->dequeueBuffer(&slot, &fence, mDisplayWidth, mDisplayHeight,

                                              PIXEL_FORMAT_RGBA_8888, GRALLOC_USAGE_SW_WRITE_OFTEN,

                                              nullptr, nullptr);

        ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, ret);

        if (IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION == ret) {

            ASSERT_EQ(OK, igbProducer->requestBuffer(slot, &buf));

        }



        nsecs_t requestedTime = systemTime() + requestedPresentTimeDelay;

        if (requestedPresentTime) *requestedPresentTime = requestedTime;

        IGraphicBufferProducer::QueueBufferInput input(requestedTime, false, HAL_DATASPACE_UNKNOWN,

        *outRequestedPresentTime = requestedPresentTime;

        IGraphicBufferProducer::QueueBufferInput input(requestedPresentTime, false,

                                                       HAL_DATASPACE_UNKNOWN,

                                                       Rect(mDisplayWidth, mDisplayHeight),

                                                       NATIVE_WINDOW_SCALING_MODE_FREEZE, 0,

                                                       Fence::NO_FENCE, /*sticky*/ 0,
@@ -1034,9 +1035,11 @@ TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_DroppedFrame) { 
    IGraphicBufferProducer::QueueBufferOutput qbOutput;

    nsecs_t requestedPresentTimeA = 0;

    nsecs_t postedTimeA = 0;

    nsecs_t presentTimeDelay = std::chrono::nanoseconds(500ms).count();

    // Present the frame sometime in the future so we can add two frames to the queue so the older

    // one will be dropped.

    nsecs_t presentTime = systemTime() + std::chrono::nanoseconds(500ms).count();

    setUpAndQueueBuffer(igbProducer, &requestedPresentTimeA, &postedTimeA, &qbOutput, true,

                        presentTimeDelay);

                        presentTime);

    history.applyDelta(qbOutput.frameTimestamps);



    FrameEvents* events = nullptr;
@@ -1049,7 +1052,10 @@ TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_DroppedFrame) { 
    // queue another buffer so the first can be dropped

    nsecs_t requestedPresentTimeB = 0;

    nsecs_t postedTimeB = 0;

    setUpAndQueueBuffer(igbProducer, &requestedPresentTimeB, &postedTimeB, &qbOutput, true);

    adapter.setTransactionCompleteCallback(2);

    presentTime = systemTime() + std::chrono::nanoseconds(1ms).count();

    setUpAndQueueBuffer(igbProducer, &requestedPresentTimeB, &postedTimeB, &qbOutput, true,

                        presentTime);

    history.applyDelta(qbOutput.frameTimestamps);

    events = history.getFrame(1);

    ASSERT_NE(nullptr, events);
@@ -1059,20 +1065,75 @@ TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_DroppedFrame) { 
    ASSERT_EQ(requestedPresentTimeA, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeA);



    // a valid latchtime should not be set

    // a valid latchtime and pre and post composition info should not be set for the dropped frame

    ASSERT_FALSE(events->hasLatchInfo());

    ASSERT_FALSE(events->hasDequeueReadyInfo());

    ASSERT_FALSE(events->hasGpuCompositionDoneInfo());

    ASSERT_FALSE(events->hasDisplayPresentInfo());

    ASSERT_FALSE(events->hasReleaseInfo());



    ASSERT_NE(nullptr, events->gpuCompositionDoneFence);

    ASSERT_NE(nullptr, events->displayPresentFence);

    ASSERT_NE(nullptr, events->releaseFence);

    // wait for the last transaction to be completed.

    adapter.waitForCallback(2);



    // we should also have gotten the initial values for the next frame

    // queue another buffer so we query for frame event deltas

    nsecs_t requestedPresentTimeC = 0;

    nsecs_t postedTimeC = 0;

    setUpAndQueueBuffer(igbProducer, &requestedPresentTimeC, &postedTimeC, &qbOutput, true);

    history.applyDelta(qbOutput.frameTimestamps);



    // frame number, requestedPresentTime, and postTime should not have changed

    ASSERT_EQ(1, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeA, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeA);



    // a valid latchtime and pre and post composition info should not be set for the dropped frame

    ASSERT_FALSE(events->hasLatchInfo());

    ASSERT_FALSE(events->hasDequeueReadyInfo());

    ASSERT_FALSE(events->hasGpuCompositionDoneInfo());

    ASSERT_FALSE(events->hasDisplayPresentInfo());

    ASSERT_FALSE(events->hasReleaseInfo());



    // we should also have gotten values for the presented frame

    events = history.getFrame(2);

    ASSERT_NE(nullptr, events);

    ASSERT_EQ(2, events->frameNumber);

    ASSERT_EQ(requestedPresentTimeB, events->requestedPresentTime);

    ASSERT_GE(events->postedTime, postedTimeB);

    ASSERT_GE(events->latchTime, postedTimeB);

    ASSERT_GE(events->dequeueReadyTime, events->latchTime);

    ASSERT_NE(nullptr, events->gpuCompositionDoneFence);

    ASSERT_NE(nullptr, events->displayPresentFence);

    ASSERT_NE(nullptr, events->releaseFence);



    // wait for any callbacks that have not been received

    adapter.waitForCallbacks();

}



TEST_F(BLASTFrameEventHistoryTest, FrameEventHistory_CompositorTimings) {

    BLASTBufferQueueHelper adapter(mSurfaceControl, mDisplayWidth, mDisplayHeight);

    sp<IGraphicBufferProducer> igbProducer;

    ProducerFrameEventHistory history;

    setUpProducer(adapter, igbProducer);



    IGraphicBufferProducer::QueueBufferOutput qbOutput;

    nsecs_t requestedPresentTimeA = 0;

    nsecs_t postedTimeA = 0;

    adapter.setTransactionCompleteCallback(1);

    setUpAndQueueBuffer(igbProducer, &requestedPresentTimeA, &postedTimeA, &qbOutput, true);

    history.applyDelta(qbOutput.frameTimestamps);

    adapter.waitForCallback(1);



    // queue another buffer so we query for frame event deltas

    nsecs_t requestedPresentTimeB = 0;

    nsecs_t postedTimeB = 0;

    setUpAndQueueBuffer(igbProducer, &requestedPresentTimeB, &postedTimeB, &qbOutput, true);

    history.applyDelta(qbOutput.frameTimestamps);



    // check for a valid compositor deadline

    ASSERT_NE(0, history.getReportedCompositeDeadline());



    // wait for any callbacks that have not been received

    adapter.waitForCallbacks();

}



} // namespace android