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 "measure_table.h"
17 #include <cmath>
18
19 namespace SysTuning {
20 namespace TraceStreamer {
21 enum class Index : int32_t { TYPE = 0, TS, DUR, VALUE, FILTER_ID };
MeasureTable(const TraceDataCache * dataCache)22 MeasureTable::MeasureTable(const TraceDataCache *dataCache) : TableBase(dataCache)
23 {
24 tableColumn_.push_back(TableBase::ColumnInfo("type", "TEXT"));
25 tableColumn_.push_back(TableBase::ColumnInfo("ts", "INTEGER"));
26 tableColumn_.push_back(TableBase::ColumnInfo("dur", "INTEGER"));
27 tableColumn_.push_back(TableBase::ColumnInfo("value", "INTEGER"));
28 tableColumn_.push_back(TableBase::ColumnInfo("filter_id", "INTEGER"));
29 tablePriKey_.push_back("ts");
30 tablePriKey_.push_back("filter_id");
31 }
32
~MeasureTable()33 MeasureTable::~MeasureTable() {}
34
CreateCursor()35 std::unique_ptr<TableBase::Cursor> MeasureTable::CreateCursor()
36 {
37 return std::make_unique<Cursor>(dataCache_, this);
38 }
39
Cursor(const TraceDataCache * dataCache,TableBase * table)40 MeasureTable::Cursor::Cursor(const TraceDataCache *dataCache, TableBase *table)
41 : TableBase::Cursor(dataCache,
42 table,
43 static_cast<uint32_t>(table->name_ == "measure"
44 ? dataCache->GetConstMeasureData().Size()
45 : (table->name_ == "process_measure"
46 ? dataCache->GetConstProcessMeasureData().Size()
47 : dataCache->GetConstSysMemMeasureData().Size()))),
48 measureObj(table->name_ == "measure"
49 ? dataCache->GetConstMeasureData()
50 : (table->name_ == "process_measure" ? dataCache->GetConstProcessMeasureData()
51 : dataCache->GetConstSysMemMeasureData()))
52 {
53 }
54
~Cursor()55 MeasureTable::Cursor::~Cursor() {}
56
FilterByConstraint(FilterConstraints & measurefc,double & measurefilterCost,size_t measurerowCount,uint32_t measurecurrenti)57 void MeasureTable::FilterByConstraint(FilterConstraints &measurefc,
58 double &measurefilterCost,
59 size_t measurerowCount,
60 uint32_t measurecurrenti)
61 {
62 // To use the EstimateFilterCost function in the TableBase parent class function to calculate the i-value of each
63 // for loop
64 const auto &measurec = measurefc.GetConstraints()[measurecurrenti];
65 switch (static_cast<Index>(measurec.col)) {
66 case Index::TS: {
67 auto measureoldRowCount = measurerowCount;
68 if (CanFilterSorted(measurec.op, measurerowCount)) {
69 measurefc.UpdateConstraint(measurecurrenti, true);
70 measurefilterCost += log2(measureoldRowCount); // binary search
71 } else {
72 measurefilterCost += measureoldRowCount;
73 }
74 break;
75 }
76 default: // other column
77 measurefilterCost += measurerowCount; // scan all rows
78 break;
79 }
80 }
81
Filter(const FilterConstraints & fc,sqlite3_value ** argv)82 int32_t MeasureTable::Cursor::Filter(const FilterConstraints &fc, sqlite3_value **argv)
83 {
84 // reset
85 indexMap_ = std::make_unique<IndexMap>(0, rowCount_);
86
87 if (rowCount_ <= 0) {
88 return SQLITE_OK;
89 }
90 auto measureTabCs = fc.GetConstraints();
91 std::set<uint32_t> sId = {static_cast<uint32_t>(Index::TS)};
92 SwapIndexFront(measureTabCs, sId);
93 for (size_t i = 0; i < measureTabCs.size(); i++) {
94 const auto &c = measureTabCs[i];
95 switch (static_cast<Index>(c.col)) {
96 case Index::TS:
97 FilterTS(c.op, argv[c.idxInaConstraint], measureObj.TimeStampData());
98 break;
99 case Index::FILTER_ID:
100 indexMap_->MixRange(c.op, static_cast<uint32_t>(sqlite3_value_int(argv[c.idxInaConstraint])),
101 measureObj.FilterIdData());
102 break;
103 default:
104 break;
105 }
106 }
107
108 auto orderbys = fc.GetOrderBys();
109 for (auto i = orderbys.size(); i > 0;) {
110 i--;
111 switch (static_cast<Index>(orderbys[i].iColumn)) {
112 case Index::TS:
113 indexMap_->SortBy(orderbys[i].desc);
114 break;
115 case Index::FILTER_ID:
116 indexMap_->SortBy(orderbys[i].desc);
117 break;
118 default:
119 break;
120 }
121 }
122
123 return SQLITE_OK;
124 }
125
Column(int32_t column) const126 int32_t MeasureTable::Cursor::Column(int32_t column) const
127 {
128 switch (static_cast<Index>(column)) {
129 case Index::TYPE:
130 sqlite3_result_text(context_, "measure", STR_DEFAULT_LEN, nullptr);
131 break;
132 case Index::TS:
133 sqlite3_result_int64(context_, static_cast<int64_t>(measureObj.TimeStampData()[CurrentRow()]));
134 break;
135 case Index::DUR:
136 if (measureObj.DursData()[CurrentRow()] != INVALID_UINT64) {
137 sqlite3_result_int64(context_, static_cast<int64_t>(measureObj.DursData()[CurrentRow()]));
138 }
139 break;
140 case Index::VALUE:
141 sqlite3_result_int64(context_, static_cast<int64_t>(measureObj.ValuesData()[CurrentRow()]));
142 break;
143 case Index::FILTER_ID:
144 sqlite3_result_int64(context_, static_cast<int32_t>(measureObj.FilterIdData()[CurrentRow()]));
145 break;
146 default:
147 TS_LOGF("Unregistered column : %d", column);
148 break;
149 }
150 return SQLITE_OK;
151 }
152
GetOrbyes(FilterConstraints & measurefc,EstimatedIndexInfo & measureei)153 void MeasureTable::GetOrbyes(FilterConstraints &measurefc, EstimatedIndexInfo &measureei)
154 {
155 auto measureorderbys = measurefc.GetOrderBys();
156 for (auto i = 0; i < measureorderbys.size(); i++) {
157 switch (static_cast<Index>(measureorderbys[i].iColumn)) {
158 case Index::TS:
159 break;
160 default: // other columns can be sorted by SQLite
161 measureei.isOrdered = false;
162 break;
163 }
164 }
165 }
166 } // namespace TraceStreamer
167 } // namespace SysTuning
168