1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "clock_filter.h"
17 #include <algorithm>
18 #include <map>
19 #include <cinttypes>
20 #include "string_help.h"
21 #include "ts_common.h"
22
23 namespace SysTuning {
24 namespace TraceStreamer {
ClockFilter()25 ClockFilter::ClockFilter() : hasInitSnapShot_(false) {}
~ClockFilter()26 ClockFilter::~ClockFilter() {}
27
GenClockKey(ClockId srcClockId,ClockId desClockId)28 std::string ClockFilter::GenClockKey(ClockId srcClockId, ClockId desClockId)
29 {
30 std::string ret;
31 ret += std::to_string(srcClockId);
32 ret += ",";
33 ret += std::to_string(desClockId);
34 return ret;
35 }
36
ToPrimaryTraceTime(ClockId srcClockId,uint64_t srcTs) const37 uint64_t ClockFilter::ToPrimaryTraceTime(ClockId srcClockId, uint64_t srcTs) const
38 {
39 if (srcClockId == g_primaryClockId) {
40 return srcTs;
41 }
42 return Convert(srcClockId, srcTs, g_primaryClockId);
43 }
44
Convert(ClockId srcClockId,uint64_t srcTs,ClockId desClockId) const45 uint64_t ClockFilter::Convert(ClockId srcClockId, uint64_t srcTs, ClockId desClockId) const
46 {
47 std::string &&clockKey = GenClockKey(srcClockId, desClockId);
48 auto keyIt = clockMaps_.find(clockKey);
49 if (keyIt == clockMaps_.end()) {
50 return srcTs;
51 }
52
53 auto tsIt = keyIt->second.upper_bound(srcTs);
54 if (tsIt != keyIt->second.begin()) {
55 tsIt--;
56 }
57
58 if (tsIt->second >= 0) {
59 return srcTs + static_cast<uint64_t>(tsIt->second);
60 } else {
61 return srcTs - static_cast<uint64_t>(0 - tsIt->second);
62 }
63 }
64
AddConvertClockMap(ClockId srcClockId,ClockId dstClockId,uint64_t srcTs,uint64_t dstTs)65 void ClockFilter::AddConvertClockMap(ClockId srcClockId, ClockId dstClockId, uint64_t srcTs, uint64_t dstTs)
66 {
67 std::string &&clockKey = GenClockKey(srcClockId, dstClockId);
68 auto keyIt = clockMaps_.find(clockKey);
69 if (keyIt == clockMaps_.end()) {
70 ConvertClockMap newConvertMap = {{srcTs, dstTs - srcTs}};
71 clockMaps_[clockKey] = newConvertMap;
72 } else {
73 clockMaps_[clockKey].insert(std::make_pair(srcTs, dstTs - srcTs));
74 }
75 }
AddClockSnapshot(const std::vector<SnapShot> & snapShot)76 void ClockFilter::AddClockSnapshot(const std::vector<SnapShot> &snapShot)
77 {
78 ClockId srcId;
79 ClockId desId;
80 for (srcId = 0; srcId < snapShot.size() - 1; srcId++) {
81 ClockId srcClockId = snapShot[srcId].clockId;
82 uint64_t srcTs = snapShot[srcId].ts;
83 for (desId = srcId + 1; desId < snapShot.size(); desId++) {
84 ClockId desClockId = snapShot[desId].clockId;
85 uint64_t desTs = snapShot[desId].ts;
86 AddConvertClockMap(srcClockId, desClockId, srcTs, desTs);
87 AddConvertClockMap(desClockId, srcClockId, desTs, srcTs);
88 }
89 }
90 hasInitSnapShot_ = true;
91 }
92
InitSnapShotTimeRange(const uint8_t * data,int32_t len)93 int32_t ClockFilter::InitSnapShotTimeRange(const uint8_t *data, int32_t len)
94 {
95 if (HasInitSnapShot()) {
96 TS_LOGE("SDK already has clock snapshot!!!");
97 return -1;
98 }
99 std::unique_ptr<uint8_t[]> buf = std::make_unique<uint8_t[]>(len);
100 std::copy(data, data + len, buf.get());
101 profilerSDKTraceFileHeader_ = reinterpret_cast<ProfilerTraceFileHeader *>(buf.get());
102 if (!profilerSDKTraceFileHeader_->data.boottime) {
103 TS_LOGE("SDK Profiler header has no clock snapshot!!!");
104 return -1;
105 }
106
107 std::vector<SnapShot> snapShot;
108
109 TS_LOGI("SDK clockid: TS_CLOCK_BOOTTIME, ts:%" PRIu64 " ", profilerSDKTraceFileHeader_->data.boottime);
110 if (profilerSDKTraceFileHeader_->data.boottime != 0) {
111 snapShot.push_back(SnapShot{TS_CLOCK_BOOTTIME, profilerSDKTraceFileHeader_->data.boottime});
112 }
113
114 TS_LOGI("SDK clockid: TS_CLOCK_REALTIME, ts:%" PRIu64 "", profilerSDKTraceFileHeader_->data.realtime);
115 if (profilerSDKTraceFileHeader_->data.realtime != 0) {
116 snapShot.push_back(SnapShot{TS_CLOCK_REALTIME, profilerSDKTraceFileHeader_->data.realtime});
117 }
118
119 TS_LOGI("SDK clockid: TS_CLOCK_REALTIME_COARSE, ts:%" PRIu64 "", profilerSDKTraceFileHeader_->data.realtimeCoarse);
120 if (profilerSDKTraceFileHeader_->data.realtimeCoarse != 0) {
121 snapShot.push_back(SnapShot{TS_CLOCK_REALTIME_COARSE, profilerSDKTraceFileHeader_->data.realtimeCoarse});
122 }
123
124 TS_LOGI("SDK clockid: TS_MONOTONIC, ts:%" PRIu64 "", profilerSDKTraceFileHeader_->data.monotonic);
125 if (profilerSDKTraceFileHeader_->data.monotonic != 0) {
126 snapShot.push_back(SnapShot{TS_MONOTONIC, profilerSDKTraceFileHeader_->data.monotonic});
127 }
128
129 TS_LOGI("SDK clockid: TS_MONOTONIC_COARSE, ts:%" PRIu64 "", profilerSDKTraceFileHeader_->data.monotonicCoarse);
130 if (profilerSDKTraceFileHeader_->data.monotonicCoarse != 0) {
131 snapShot.push_back(SnapShot{TS_MONOTONIC_COARSE, profilerSDKTraceFileHeader_->data.monotonicCoarse});
132 }
133
134 TS_LOGI("SDK clockid: TS_MONOTONIC_RAW, ts:%" PRIu64 "", profilerSDKTraceFileHeader_->data.monotonicRaw);
135 if (profilerSDKTraceFileHeader_->data.monotonicRaw != 0) {
136 snapShot.push_back(SnapShot{TS_MONOTONIC_RAW, profilerSDKTraceFileHeader_->data.monotonicRaw});
137 }
138
139 if (!snapShot.empty()) {
140 AddClockSnapshot(snapShot);
141 }
142 return 0;
143 }
144 } // namespace TraceStreamer
145 } // namespace SysTuning
146