include/gui/FrameTimestamps.h - android_frameworks_native - Gitiles

 /*
  * Copyright 2016 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.
  */

 #ifndef ANDROID_GUI_FRAMETIMESTAMPS_H
 #define ANDROID_GUI_FRAMETIMESTAMPS_H

 #include <ui/FenceTime.h>
 #include <utils/Flattenable.h>
 #include <utils/StrongPointer.h>
 #include <utils/Timers.h>

 #include <array>
 #include <bitset>
 #include <vector>

 namespace android {

 struct FrameEvents;
 class FrameEventHistoryDelta;
 class String8;


 // Identifiers for all the events that may be recorded or reported.
 enum class FrameEvent {
     POSTED,
     REQUESTED_PRESENT,
     LATCH,
     ACQUIRE,
     FIRST_REFRESH_START,
     LAST_REFRESH_START,
     GPU_COMPOSITION_DONE,
     DISPLAY_PRESENT,
     DEQUEUE_READY,
     RELEASE,
     EVENT_COUNT, // Not an actual event.
 };


 // A collection of timestamps corresponding to a single frame.
 struct FrameEvents {
     static constexpr auto EVENT_COUNT =
             static_cast<size_t>(FrameEvent::EVENT_COUNT);
     static_assert(EVENT_COUNT <= 32, "Event count sanity check failed.");
     static constexpr nsecs_t TIMESTAMP_PENDING =
             std::numeric_limits<nsecs_t>::max();

     static inline bool isValidTimestamp(nsecs_t time) {
         return time != TIMESTAMP_PENDING;
     }

     bool hasPostedInfo() const;
     bool hasRequestedPresentInfo() const;
     bool hasLatchInfo() const;
     bool hasFirstRefreshStartInfo() const;
     bool hasLastRefreshStartInfo() const;
     bool hasAcquireInfo() const;
     bool hasGpuCompositionDoneInfo() const;
     bool hasDisplayPresentInfo() const;
     bool hasReleaseInfo() const;
     bool hasDequeueReadyInfo() const;

     void checkFencesForCompletion();
     void dump(String8& outString) const;

     bool valid{false};
     int connectId{0};
     uint64_t frameNumber{0};

     // Whether or not certain points in the frame's life cycle have been
     // encountered help us determine if timestamps aren't available because
     // a) we'll just never get them or b) they're not ready yet.
     bool addPostCompositeCalled{false};
     bool addReleaseCalled{false};

     nsecs_t postedTime{TIMESTAMP_PENDING};
     nsecs_t requestedPresentTime{TIMESTAMP_PENDING};
     nsecs_t latchTime{TIMESTAMP_PENDING};
     nsecs_t firstRefreshStartTime{TIMESTAMP_PENDING};
     nsecs_t lastRefreshStartTime{TIMESTAMP_PENDING};
     nsecs_t dequeueReadyTime{TIMESTAMP_PENDING};

     std::shared_ptr<FenceTime> acquireFence{FenceTime::NO_FENCE};
     std::shared_ptr<FenceTime> gpuCompositionDoneFence{FenceTime::NO_FENCE};
     std::shared_ptr<FenceTime> displayPresentFence{FenceTime::NO_FENCE};
     std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};
 };

 struct CompositorTiming {
     nsecs_t deadline{0};
     nsecs_t interval{16666667};
     nsecs_t presentLatency{16666667};
 };

 // A short history of frames that are synchronized between the consumer and
 // producer via deltas.
 class FrameEventHistory {
 public:
     virtual ~FrameEventHistory();

     FrameEvents* getFrame(uint64_t frameNumber);
     FrameEvents* getFrame(uint64_t frameNumber, size_t* iHint);
     void checkFencesForCompletion();
     void dump(String8& outString) const;

     static constexpr size_t MAX_FRAME_HISTORY = 8;

 protected:
     std::array<FrameEvents, MAX_FRAME_HISTORY> mFrames;

     CompositorTiming mCompositorTiming;
 };


 // The producer's interface to FrameEventHistory
 class ProducerFrameEventHistory : public FrameEventHistory {
 public:
     ~ProducerFrameEventHistory() override;

     // Public for testing.
     static nsecs_t snapToNextTick(
             nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval);

     nsecs_t getNextCompositeDeadline(const nsecs_t now) const;
     nsecs_t getCompositeInterval() const { return mCompositorTiming.interval; }
     nsecs_t getCompositeToPresentLatency() const {
         return mCompositorTiming.presentLatency;
     }

     // virtual for testing.
     virtual void updateAcquireFence(
             uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire);
     void applyDelta(const FrameEventHistoryDelta& delta);

     void updateSignalTimes();

 protected:
     void applyFenceDelta(FenceTimeline* timeline,
             std::shared_ptr<FenceTime>* dst,
             const FenceTime::Snapshot& src) const;

     // virtual for testing.
     virtual std::shared_ptr<FenceTime> createFenceTime(
             const sp<Fence>& fence) const;

     size_t mAcquireOffset{0};

     // The consumer updates it's timelines in Layer and SurfaceFlinger since
     // they can coordinate shared timelines better. The producer doesn't have
     // shared timelines though, so just let it own and update all of them.
     FenceTimeline mAcquireTimeline;
     FenceTimeline mGpuCompositionDoneTimeline;
     FenceTimeline mPresentTimeline;
     FenceTimeline mReleaseTimeline;
 };


 // Used by the consumer to create a new frame event record that is
 // partially complete.
 struct NewFrameEventsEntry {
     uint64_t frameNumber{0};
     nsecs_t postedTime{0};
     nsecs_t requestedPresentTime{0};
     std::shared_ptr<FenceTime> acquireFence{FenceTime::NO_FENCE};
 };


 // Used by the consumer to keep track of which fields it already sent to
 // the producer.
 class FrameEventDirtyFields {
 public:
     inline void reset() { mBitset.reset(); }
     inline bool anyDirty() const { return mBitset.any(); }

     template <FrameEvent event>
     inline void setDirty() {
         constexpr size_t eventIndex = static_cast<size_t>(event);
         static_assert(eventIndex < FrameEvents::EVENT_COUNT, "Bad index.");
         mBitset.set(eventIndex);
     }

     template <FrameEvent event>
     inline bool isDirty() const {
         constexpr size_t eventIndex = static_cast<size_t>(event);
         static_assert(eventIndex < FrameEvents::EVENT_COUNT, "Bad index.");
         return mBitset[eventIndex];
     }

 private:
     std::bitset<FrameEvents::EVENT_COUNT> mBitset;
 };


 // The consumer's interface to FrameEventHistory
 class ConsumerFrameEventHistory : public FrameEventHistory {
 public:
     ~ConsumerFrameEventHistory() override;

     void onDisconnect();

     void initializeCompositorTiming(const CompositorTiming& compositorTiming);

     void addQueue(const NewFrameEventsEntry& newEntry);
     void addLatch(uint64_t frameNumber, nsecs_t latchTime);
     void addPreComposition(uint64_t frameNumber, nsecs_t refreshStartTime);
     void addPostComposition(uint64_t frameNumber,
             const std::shared_ptr<FenceTime>& gpuCompositionDone,
             const std::shared_ptr<FenceTime>& displayPresent,
             const CompositorTiming& compositorTiming);
     void addRelease(uint64_t frameNumber, nsecs_t dequeueReadyTime,
             std::shared_ptr<FenceTime>&& release);

     void getAndResetDelta(FrameEventHistoryDelta* delta);

 private:
     void getFrameDelta(FrameEventHistoryDelta* delta,
             const std::array<FrameEvents, MAX_FRAME_HISTORY>::iterator& frame);

     std::array<FrameEventDirtyFields, MAX_FRAME_HISTORY> mFramesDirty;

     size_t mQueueOffset{0};
     size_t mCompositionOffset{0};
     size_t mReleaseOffset{0};

     int mCurrentConnectId{0};
     bool mProducerWantsEvents{false};
 };


 // A single frame update from the consumer to producer that can be sent
 // through Binder.
 // Although this may be sent multiple times for the same frame as new
 // timestamps are set, Fences only need to be sent once.
 class FrameEventsDelta : public Flattenable<FrameEventsDelta> {
 friend class ProducerFrameEventHistory;
 public:
     FrameEventsDelta() = default;
     FrameEventsDelta(size_t index,
             const FrameEvents& frameTimestamps,
             const FrameEventDirtyFields& dirtyFields);

     // Movable.
     FrameEventsDelta(FrameEventsDelta&& src) = default;
     FrameEventsDelta& operator=(FrameEventsDelta&& src) = default;
     // Not copyable.
     FrameEventsDelta(const FrameEventsDelta& src) = delete;
     FrameEventsDelta& operator=(const FrameEventsDelta& src) = delete;

     // Flattenable implementation
     size_t getFlattenedSize() const;
     size_t getFdCount() const;
     status_t flatten(void*& buffer, size_t& size, int*& fds,
             size_t& count) const;
     status_t unflatten(void const*& buffer, size_t& size, int const*& fds,
             size_t& count);

 private:
     static constexpr size_t minFlattenedSize();

     size_t mIndex{0};
     uint64_t mFrameNumber{0};

     bool mAddPostCompositeCalled{0};
     bool mAddReleaseCalled{0};

     nsecs_t mPostedTime{FrameEvents::TIMESTAMP_PENDING};
     nsecs_t mRequestedPresentTime{FrameEvents::TIMESTAMP_PENDING};
     nsecs_t mLatchTime{FrameEvents::TIMESTAMP_PENDING};
     nsecs_t mFirstRefreshStartTime{FrameEvents::TIMESTAMP_PENDING};
     nsecs_t mLastRefreshStartTime{FrameEvents::TIMESTAMP_PENDING};
     nsecs_t mDequeueReadyTime{FrameEvents::TIMESTAMP_PENDING};

     FenceTime::Snapshot mGpuCompositionDoneFence;
     FenceTime::Snapshot mDisplayPresentFence;
     FenceTime::Snapshot mReleaseFence;

     // This is a static method with an auto return value so we can call
     // it without needing const and non-const versions.
     template <typename ThisT>
     static inline auto allFences(ThisT fed) ->
             std::array<decltype(&fed->mReleaseFence), 3> {
         return {{
             &fed->mGpuCompositionDoneFence, &fed->mDisplayPresentFence,
             &fed->mReleaseFence
         }};
     }
 };


 // A collection of updates from consumer to producer that can be sent
 // through Binder.
 class FrameEventHistoryDelta
         : public Flattenable<FrameEventHistoryDelta> {

 friend class ConsumerFrameEventHistory;
 friend class ProducerFrameEventHistory;

 public:
     FrameEventHistoryDelta() = default;

     // Movable.
     FrameEventHistoryDelta(FrameEventHistoryDelta&& src) = default;
     FrameEventHistoryDelta& operator=(FrameEventHistoryDelta&& src);
     // Not copyable.
     FrameEventHistoryDelta(const FrameEventHistoryDelta& src) = delete;
     FrameEventHistoryDelta& operator=(
             const FrameEventHistoryDelta& src) = delete;

     // Flattenable implementation.
     size_t getFlattenedSize() const;
     size_t getFdCount() const;
     status_t flatten(void*& buffer, size_t& size, int*& fds,
             size_t& count) const;
     status_t unflatten(void const*& buffer, size_t& size, int const*& fds,
             size_t& count);

 private:
     static constexpr size_t minFlattenedSize();

     std::vector<FrameEventsDelta> mDeltas;
     CompositorTiming mCompositorTiming;
 };


 } // namespace android
 #endif
	/*
	* Copyright 2016 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.
	*/

	#ifndef ANDROID_GUI_FRAMETIMESTAMPS_H
	#define ANDROID_GUI_FRAMETIMESTAMPS_H

	#include <ui/FenceTime.h>
	#include <utils/Flattenable.h>
	#include <utils/StrongPointer.h>
	#include <utils/Timers.h>

	#include <array>
	#include <bitset>
	#include <vector>

	namespace android {

	struct FrameEvents;
	class FrameEventHistoryDelta;
	class String8;


	// Identifiers for all the events that may be recorded or reported.
	enum class FrameEvent {
	POSTED,
	REQUESTED_PRESENT,
	LATCH,
	ACQUIRE,
	FIRST_REFRESH_START,
	LAST_REFRESH_START,
	GPU_COMPOSITION_DONE,
	DISPLAY_PRESENT,
	DEQUEUE_READY,
	RELEASE,
	EVENT_COUNT, // Not an actual event.
	};


	// A collection of timestamps corresponding to a single frame.
	struct FrameEvents {
	static constexpr auto EVENT_COUNT =
	static_cast<size_t>(FrameEvent::EVENT_COUNT);
	static_assert(EVENT_COUNT <= 32, "Event count sanity check failed.");
	static constexpr nsecs_t TIMESTAMP_PENDING =
	std::numeric_limits<nsecs_t>::max();

	static inline bool isValidTimestamp(nsecs_t time) {
	return time != TIMESTAMP_PENDING;
	}

	bool hasPostedInfo() const;
	bool hasRequestedPresentInfo() const;
	bool hasLatchInfo() const;
	bool hasFirstRefreshStartInfo() const;
	bool hasLastRefreshStartInfo() const;
	bool hasAcquireInfo() const;
	bool hasGpuCompositionDoneInfo() const;
	bool hasDisplayPresentInfo() const;
	bool hasReleaseInfo() const;
	bool hasDequeueReadyInfo() const;

	void checkFencesForCompletion();
	void dump(String8& outString) const;

	bool valid{false};
	int connectId{0};
	uint64_t frameNumber{0};

	// Whether or not certain points in the frame's life cycle have been
	// encountered help us determine if timestamps aren't available because
	// a) we'll just never get them or b) they're not ready yet.
	bool addPostCompositeCalled{false};
	bool addReleaseCalled{false};

	nsecs_t postedTime{TIMESTAMP_PENDING};
	nsecs_t requestedPresentTime{TIMESTAMP_PENDING};
	nsecs_t latchTime{TIMESTAMP_PENDING};
	nsecs_t firstRefreshStartTime{TIMESTAMP_PENDING};
	nsecs_t lastRefreshStartTime{TIMESTAMP_PENDING};
	nsecs_t dequeueReadyTime{TIMESTAMP_PENDING};

	std::shared_ptr<FenceTime> acquireFence{FenceTime::NO_FENCE};
	std::shared_ptr<FenceTime> gpuCompositionDoneFence{FenceTime::NO_FENCE};
	std::shared_ptr<FenceTime> displayPresentFence{FenceTime::NO_FENCE};
	std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};
	};

	struct CompositorTiming {
	nsecs_t deadline{0};
	nsecs_t interval{16666667};
	nsecs_t presentLatency{16666667};
	};

	// A short history of frames that are synchronized between the consumer and
	// producer via deltas.
	class FrameEventHistory {
	public:
	virtual ~FrameEventHistory();

	FrameEvents* getFrame(uint64_t frameNumber);
	FrameEvents* getFrame(uint64_t frameNumber, size_t* iHint);
	void checkFencesForCompletion();
	void dump(String8& outString) const;

	static constexpr size_t MAX_FRAME_HISTORY = 8;

	protected:
	std::array<FrameEvents, MAX_FRAME_HISTORY> mFrames;

	CompositorTiming mCompositorTiming;
	};


	// The producer's interface to FrameEventHistory
	class ProducerFrameEventHistory : public FrameEventHistory {
	public:
	~ProducerFrameEventHistory() override;

	// Public for testing.
	static nsecs_t snapToNextTick(
	nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval);

	nsecs_t getNextCompositeDeadline(const nsecs_t now) const;
	nsecs_t getCompositeInterval() const { return mCompositorTiming.interval; }
	nsecs_t getCompositeToPresentLatency() const {
	return mCompositorTiming.presentLatency;
	}

	// virtual for testing.
	virtual void updateAcquireFence(
	uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire);
	void applyDelta(const FrameEventHistoryDelta& delta);

	void updateSignalTimes();

	protected:
	void applyFenceDelta(FenceTimeline* timeline,
	std::shared_ptr<FenceTime>* dst,
	const FenceTime::Snapshot& src) const;

	// virtual for testing.
	virtual std::shared_ptr<FenceTime> createFenceTime(
	const sp<Fence>& fence) const;

	size_t mAcquireOffset{0};

	// The consumer updates it's timelines in Layer and SurfaceFlinger since
	// they can coordinate shared timelines better. The producer doesn't have
	// shared timelines though, so just let it own and update all of them.
	FenceTimeline mAcquireTimeline;
	FenceTimeline mGpuCompositionDoneTimeline;
	FenceTimeline mPresentTimeline;
	FenceTimeline mReleaseTimeline;
	};


	// Used by the consumer to create a new frame event record that is
	// partially complete.
	struct NewFrameEventsEntry {
	uint64_t frameNumber{0};
	nsecs_t postedTime{0};
	nsecs_t requestedPresentTime{0};
	std::shared_ptr<FenceTime> acquireFence{FenceTime::NO_FENCE};
	};


	// Used by the consumer to keep track of which fields it already sent to
	// the producer.
	class FrameEventDirtyFields {
	public:
	inline void reset() { mBitset.reset(); }
	inline bool anyDirty() const { return mBitset.any(); }

	template <FrameEvent event>
	inline void setDirty() {
	constexpr size_t eventIndex = static_cast<size_t>(event);
	static_assert(eventIndex < FrameEvents::EVENT_COUNT, "Bad index.");
	mBitset.set(eventIndex);
	}

	template <FrameEvent event>
	inline bool isDirty() const {
	constexpr size_t eventIndex = static_cast<size_t>(event);
	static_assert(eventIndex < FrameEvents::EVENT_COUNT, "Bad index.");
	return mBitset[eventIndex];
	}

	private:
	std::bitset<FrameEvents::EVENT_COUNT> mBitset;
	};


	// The consumer's interface to FrameEventHistory
	class ConsumerFrameEventHistory : public FrameEventHistory {
	public:
	~ConsumerFrameEventHistory() override;

	void onDisconnect();

	void initializeCompositorTiming(const CompositorTiming& compositorTiming);

	void addQueue(const NewFrameEventsEntry& newEntry);
	void addLatch(uint64_t frameNumber, nsecs_t latchTime);
	void addPreComposition(uint64_t frameNumber, nsecs_t refreshStartTime);
	void addPostComposition(uint64_t frameNumber,
	const std::shared_ptr<FenceTime>& gpuCompositionDone,
	const std::shared_ptr<FenceTime>& displayPresent,
	const CompositorTiming& compositorTiming);
	void addRelease(uint64_t frameNumber, nsecs_t dequeueReadyTime,
	std::shared_ptr<FenceTime>&& release);

	void getAndResetDelta(FrameEventHistoryDelta* delta);

	private:
	void getFrameDelta(FrameEventHistoryDelta* delta,
	const std::array<FrameEvents, MAX_FRAME_HISTORY>::iterator& frame);

	std::array<FrameEventDirtyFields, MAX_FRAME_HISTORY> mFramesDirty;

	size_t mQueueOffset{0};
	size_t mCompositionOffset{0};
	size_t mReleaseOffset{0};

	int mCurrentConnectId{0};
	bool mProducerWantsEvents{false};
	};


	// A single frame update from the consumer to producer that can be sent
	// through Binder.
	// Although this may be sent multiple times for the same frame as new
	// timestamps are set, Fences only need to be sent once.
	class FrameEventsDelta : public Flattenable<FrameEventsDelta> {
	friend class ProducerFrameEventHistory;
	public:
	FrameEventsDelta() = default;
	FrameEventsDelta(size_t index,
	const FrameEvents& frameTimestamps,
	const FrameEventDirtyFields& dirtyFields);

	// Movable.
	FrameEventsDelta(FrameEventsDelta&& src) = default;
	FrameEventsDelta& operator=(FrameEventsDelta&& src) = default;
	// Not copyable.
	FrameEventsDelta(const FrameEventsDelta& src) = delete;
	FrameEventsDelta& operator=(const FrameEventsDelta& src) = delete;

	// Flattenable implementation
	size_t getFlattenedSize() const;
	size_t getFdCount() const;
	status_t flatten(void& buffer, size_t& size, int& fds,
	size_t& count) const;
	status_t unflatten(void const& buffer, size_t& size, int const& fds,
	size_t& count);

	private:
	static constexpr size_t minFlattenedSize();

	size_t mIndex{0};
	uint64_t mFrameNumber{0};

	bool mAddPostCompositeCalled{0};
	bool mAddReleaseCalled{0};

	nsecs_t mPostedTime{FrameEvents::TIMESTAMP_PENDING};
	nsecs_t mRequestedPresentTime{FrameEvents::TIMESTAMP_PENDING};
	nsecs_t mLatchTime{FrameEvents::TIMESTAMP_PENDING};
	nsecs_t mFirstRefreshStartTime{FrameEvents::TIMESTAMP_PENDING};
	nsecs_t mLastRefreshStartTime{FrameEvents::TIMESTAMP_PENDING};
	nsecs_t mDequeueReadyTime{FrameEvents::TIMESTAMP_PENDING};

	FenceTime::Snapshot mGpuCompositionDoneFence;
	FenceTime::Snapshot mDisplayPresentFence;
	FenceTime::Snapshot mReleaseFence;

	// This is a static method with an auto return value so we can call
	// it without needing const and non-const versions.
	template <typename ThisT>
	static inline auto allFences(ThisT fed) ->
	std::array<decltype(&fed->mReleaseFence), 3> {
	return {{
	&fed->mGpuCompositionDoneFence, &fed->mDisplayPresentFence,
	&fed->mReleaseFence
	}};
	}
	};


	// A collection of updates from consumer to producer that can be sent
	// through Binder.
	class FrameEventHistoryDelta
	: public Flattenable<FrameEventHistoryDelta> {

	friend class ConsumerFrameEventHistory;
	friend class ProducerFrameEventHistory;

	public:
	FrameEventHistoryDelta() = default;

	// Movable.
	FrameEventHistoryDelta(FrameEventHistoryDelta&& src) = default;
	FrameEventHistoryDelta& operator=(FrameEventHistoryDelta&& src);
	// Not copyable.
	FrameEventHistoryDelta(const FrameEventHistoryDelta& src) = delete;
	FrameEventHistoryDelta& operator=(
	const FrameEventHistoryDelta& src) = delete;

	// Flattenable implementation.
	size_t getFlattenedSize() const;
	size_t getFdCount() const;
	status_t flatten(void& buffer, size_t& size, int& fds,
	size_t& count) const;
	status_t unflatten(void const& buffer, size_t& size, int const& fds,
	size_t& count);

	private:
	static constexpr size_t minFlattenedSize();

	std::vector<FrameEventsDelta> mDeltas;
	CompositorTiming mCompositorTiming;
	};


	} // namespace android
	#endif