1 /*
2  * Copyright 2021 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 <android-base/file.h>
20 #include <android-base/stringprintf.h>
21 
22 #include <log/log.h>
23 #include <utils/Errors.h>
24 #include <utils/Timers.h>
25 #include <utils/Trace.h>
26 #include <chrono>
27 #include <fstream>
28 #include <queue>
29 
30 namespace android {
31 
32 class SurfaceFlinger;
33 
34 template <typename FileProto, typename EntryProto>
35 class TransactionRingBuffer {
36 public:
size()37     size_t size() const { return mSizeInBytes; }
used()38     size_t used() const { return mUsedInBytes; }
frameCount()39     size_t frameCount() const { return mStorage.size(); }
setSize(size_t newSize)40     void setSize(size_t newSize) { mSizeInBytes = newSize; }
front()41     const std::string& front() const { return mStorage.front(); }
back()42     const std::string& back() const { return mStorage.back(); }
43 
reset()44     void reset() {
45         // use the swap trick to make sure memory is released
46         std::deque<std::string>().swap(mStorage);
47         mUsedInBytes = 0U;
48     }
49 
writeToProto(FileProto & fileProto)50     void writeToProto(FileProto& fileProto) const {
51         fileProto.mutable_entry()->Reserve(static_cast<int>(mStorage.size()) +
52                                            fileProto.entry().size());
53         for (const std::string& entry : mStorage) {
54             EntryProto* entryProto = fileProto.add_entry();
55             entryProto->ParseFromString(entry);
56         }
57     }
58 
appendToStream(FileProto & fileProto,std::ofstream & out)59     status_t appendToStream(FileProto& fileProto, std::ofstream& out) {
60         ATRACE_CALL();
61         writeToProto(fileProto);
62         std::string output;
63         if (!fileProto.SerializeToString(&output)) {
64             ALOGE("Could not serialize proto.");
65             return UNKNOWN_ERROR;
66         }
67 
68         out << output;
69         return NO_ERROR;
70     }
71 
emplace(std::string && serializedProto)72     std::vector<std::string> emplace(std::string&& serializedProto) {
73         std::vector<std::string> replacedEntries;
74         size_t protoSize = static_cast<size_t>(serializedProto.size());
75         while (mUsedInBytes + protoSize > mSizeInBytes) {
76             if (mStorage.empty()) {
77                 return {};
78             }
79             mUsedInBytes -= static_cast<size_t>(mStorage.front().size());
80             replacedEntries.emplace_back(mStorage.front());
81             mStorage.pop_front();
82         }
83         mUsedInBytes += protoSize;
84         mStorage.emplace_back(serializedProto);
85         return replacedEntries;
86     }
87 
emplace(EntryProto && proto)88     std::vector<std::string> emplace(EntryProto&& proto) {
89         std::string serializedProto;
90         proto.SerializeToString(&serializedProto);
91         return emplace(std::move(serializedProto));
92     }
93 
dump(std::string & result)94     void dump(std::string& result) const {
95         std::chrono::milliseconds duration(0);
96         if (frameCount() > 0) {
97             EntryProto entry;
98             entry.ParseFromString(mStorage.front());
99             duration = std::chrono::duration_cast<std::chrono::milliseconds>(
100                     std::chrono::nanoseconds(systemTime() - entry.elapsed_realtime_nanos()));
101         }
102         const int64_t durationCount = duration.count();
103         base::StringAppendF(&result,
104                             "  number of entries: %zu (%.2fMB / %.2fMB) duration: %" PRIi64 "ms\n",
105                             frameCount(), float(used()) / (1024.f * 1024.f),
106                             float(size()) / (1024.f * 1024.f), durationCount);
107     }
108 
109 private:
110     size_t mUsedInBytes = 0U;
111     size_t mSizeInBytes = 0U;
112     std::deque<std::string> mStorage;
113 };
114 
115 } // namespace android
116