1 /*
2  * Copyright 2022 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #pragma once
18 
19 #include <semaphore.h>
20 #include <cstdint>
21 #include <optional>
22 #include <vector>
23 
24 #include <LocklessQueue.h>
25 #include <TransactionState.h>
26 #include <android-base/thread_annotations.h>
27 #include <ftl/small_map.h>
28 #include <ftl/small_vector.h>
29 
30 namespace android {
31 
32 class TestableSurfaceFlinger;
33 namespace surfaceflinger::frontend {
34 
35 class TransactionHandler {
36 public:
37     struct TransactionFlushState {
38         TransactionState* transaction;
39         bool firstTransaction = true;
40         nsecs_t queueProcessTime = 0;
41         // Layer handles that have transactions with buffers that are ready to be applied.
42         ftl::SmallMap<IBinder* /* binder address */, uint64_t /* framenumber */, 15>
43                 bufferLayersReadyToPresent = {};
44         // Tracks the queue with an unsignaled buffer. This is used to handle
45         // LatchUnsignaledConfig::AutoSingleLayer to ensure we only apply an unsignaled buffer
46         // if it's the only transaction that is ready to be applied.
47         sp<IBinder> queueWithUnsignaledBuffer = nullptr;
48     };
49     enum class TransactionReadiness {
50         // Transaction is ready to be applied
51         Ready,
52         // Transaction has unmet conditions (fence, present time, etc) and cannot be applied.
53         NotReady,
54         // Transaction is waiting on a barrier (another buffer to be latched first)
55         NotReadyBarrier,
56         // Transaction has an unsignaled fence but can be applied if it's the only transaction
57         NotReadyUnsignaled,
58     };
59     using TransactionFilter = std::function<TransactionReadiness(const TransactionFlushState&)>;
60 
61     bool hasPendingTransactions();
62     // Moves transactions from the lockless queue.
63     void collectTransactions();
64     std::vector<TransactionState> flushTransactions();
65     void addTransactionReadyFilter(TransactionFilter&&);
66     void queueTransaction(TransactionState&&);
67 
68     struct StalledTransactionInfo {
69         pid_t pid;
70         uint32_t layerId;
71         std::string layerName;
72         uint64_t bufferId;
73         uint64_t frameNumber;
74     };
75     void onTransactionQueueStalled(uint64_t transactionId, StalledTransactionInfo);
76     void removeFromStalledTransactions(uint64_t transactionId);
77     std::optional<StalledTransactionInfo> getStalledTransactionInfo(pid_t pid);
78     void onLayerDestroyed(uint32_t layerId);
79 
80 private:
81     // For unit tests
82     friend class ::android::TestableSurfaceFlinger;
83 
84     int flushPendingTransactionQueues(std::vector<TransactionState>&, TransactionFlushState&);
85     void applyUnsignaledBufferTransaction(std::vector<TransactionState>&, TransactionFlushState&);
86     void popTransactionFromPending(std::vector<TransactionState>&, TransactionFlushState&,
87                                    std::queue<TransactionState>&);
88     TransactionReadiness applyFilters(TransactionFlushState&);
89     std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash>
90             mPendingTransactionQueues;
91     LocklessQueue<TransactionState> mLocklessTransactionQueue;
92     std::atomic<size_t> mPendingTransactionCount = 0;
93     ftl::SmallVector<TransactionFilter, 2> mTransactionReadyFilters;
94 
95     std::mutex mStalledMutex;
96     std::unordered_map<uint64_t /* transactionId */, StalledTransactionInfo> mStalledTransactions
97             GUARDED_BY(mStalledMutex);
98 };
99 } // namespace surfaceflinger::frontend
100 } // namespace android
101