openharmony/developtools_hiperf
1
0
Fork 0
mirror of https://gitee.com/openharmony/developtools_hiperf synced 2024-11-23 23:49:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8395eb3cd1
developtools_hiperf/include/report_json_file.h
wenlong12 e356db195a fix codecheck issues 
Signed-off-by: wenlong12 <wenlong12@huawei.com>

Signed-off-by: wenlong12 <wwx1097114@DESKTOP-2021EGU.localdomain>
2022-03-25 11:49:41 +08:00

419 lines
13 KiB
C++
Raw Blame History

/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* 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 REPORT_JSON_FILE_H
#define REPORT_JSON_FILE_H
#include <algorithm>
#include <cstdlib>
#include <functional>
#include <map>
#include <stdio.h>
#include "debug_logger.h"
#include "perf_file_reader.h"
#include "utilities.h"
#include "virtual_runtime.h"
namespace OHOS {
namespace Developtools {
namespace HiPerf {
using jsonStringMap = std::map<std::string, std::string>;
using jsonStringVector = std::vector<std::string>;
using jsonIntVector = std::vector<int>;
template<class T>
void OutputJsonKey(FILE *output, const T &value)
{
if constexpr (std::is_same<T, std::string>::value) {
if (value.empty()) {
// for key vector [] mode, not key is needed
return;
}
fprintf(output, "\"%s\":", value.c_str());
} else if constexpr (std::is_same<T, std::string_view>::value) {
if (value.empty()) {
// for key vector [] mode, not key is needed
return;
}
fprintf(output, "\"%s\":", value.data());
} else if constexpr (std::is_same<typename std::decay<T>::type, char *>::value) {
if (value[0] == '\0') {
// same as value.empty()
return;
}
fprintf(output, "\"%s\":", value);
} else {
fprintf(output, "\"%s\":", std::to_string(value).c_str());
}
}
template<class T>
void OutputJsonValue(FILE *output, const T &value, bool first = true)
{
if (!first) {
fprintf(output, ",");
}
if constexpr (std::is_same<T, std::string>::value) {
fprintf(output, "\"%s\"", value.c_str());
} else if constexpr (std::is_same<T, std::string_view>::value) {
fprintf(output, "\"%s\"", value.data());
} else if constexpr (std::is_same<T, int>::value) {
fprintf(output, "%s", std::to_string(value).c_str());
} else if constexpr (std::is_same<T, uint64_t>::value) {
fprintf(output, "%s", std::to_string(value).c_str());
} else if constexpr (std::is_same<T, bool>::value) {
fprintf(output, "%s", std::to_string(value).c_str());
} else if constexpr (std::is_same<T, size_t>::value) {
fprintf(output, "%s", std::to_string(value).c_str());
} else if constexpr (std::is_same<typename std::decay<T>::type, char *>::value) {
fprintf(output, "\"%s\"", value);
} else {
value.OutputJson(output);
}
}
/*
k:"v"
k:1
*/
template<class K, class T>
void OutputJsonPair(FILE *output, const K &key, const T &value, bool first = false)
{
if (!first) {
if (fprintf(output, ",") < 0) {
return;
}
}
OutputJsonKey(output, key);
OutputJsonValue(output, value);
}
/*
k:[v1,v2,v3]
*/
template<class T>
void OutputJsonVectorList(FILE *output, const std::string &key, const std::vector<T> &value,
bool first = false)
{
if (!first) {
if (fprintf(output, ",") < 0) {
return;
}
}
if (fprintf(output, "\"%s\":[", key.c_str()) != -1) {
auto it = value.begin();
while (it != value.end()) {
OutputJsonValue(output, *it, it == value.begin());
it++;
}
if (fprintf(output, "]") < 0) {
return;
}
}
}
/*
k:[v1,v2,v3]
*/
template<class K, class V>
void OutputJsonMapList(FILE *output, const std::string &key, const std::map<K, V> &value,
bool first = false)
{
if (!first) {
if (fprintf(output, ",") < 0) {
return;
}
}
if (fprintf(output, "\"%s\":[", key.c_str()) != -1) {
auto it = value.begin();
while (it != value.end()) {
OutputJsonValue(output, it->second, it == value.begin());
it++;
}
if (fprintf(output, "]") < 0) {
return;
}
}
}
/*
k:{k1:v1,k2:v2,k3:v3}
*/
template<class K, class V>
void OutputJsonMap(FILE *output, const std::string &key, const std::map<K, V> &value,
bool first = false)
{
if (!first) {
if (fprintf(output, ",") < 0) {
return;
}
}
if (fprintf(output, "\"%s\":{", key.c_str()) != -1) {
auto it = value.begin();
while (it != value.end()) {
OutputJsonPair(output, it->first, it->second, it == value.begin());
it++;
}
if (fprintf(output, "}") < 0) {
return;
}
}
}
template<class K, class V>
V &GetOrCreateMapItem(std::map<K, V> &map, const K &key)
{
if (map.count(key) == 0) {
map.emplace(key, (key));
return map.at(key);
} else {
return map.at(key);
}
}
struct ReportFuncMapItem {
int libId_ = -1;
std::string_view funcName_;
void OutputJson(FILE *output) const
{
if (fprintf(output, "{") < 0) {
return;
}
OutputJsonPair(output, "file", libId_, true);
OutputJsonPair(output, "symbol", funcName_);
if (fprintf(output, "}") < 0) {
return;
}
}
ReportFuncMapItem(int libId, std::string_view funcName) : libId_(libId), funcName_(funcName) {}
};
struct ReportFuncItem {
int functionId_ = -1;
int functionInLibId_ = -1;
uint64_t sampleCount_ = 0;
uint64_t eventCount_ = 0;
uint64_t subTreeEventCount_ = 0;
explicit ReportFuncItem(int functionId) : functionId_(functionId) {}
void OutputJson(FILE *output) const
{
if (fprintf(output, "{") < 0) {
return;
}
OutputJsonPair(output, "symbol", functionId_, true);
OutputJsonVectorList(output, "counts",
std::vector<uint64_t> {sampleCount_, eventCount_, subTreeEventCount_});
if (fprintf(output, "}") < 0) {
return;
}
}
};
struct ReportCallNodeItem {
uint64_t selfEventCount_ = 0;
uint64_t subTreeEventCount_ = 0;
int functionId_ = -1;
int nodeIndex_ = -1;
bool reverseCaller_ = false;
std::string_view funcName_ = "";
std::string debug_ = "";
std::map<int, ReportCallNodeItem> childrenMap;
void OutputJson(FILE *output) const
{
if (fprintf(output, "{") < 0) {
return;
}
OutputJsonPair(output, "selfEvents", selfEventCount_, true);
OutputJsonPair(output, "subEvents", subTreeEventCount_);
OutputJsonPair(output, "symbol", functionId_);
if (!funcName_.empty()) { // for debug
OutputJsonPair(output, "funcName", funcName_);
OutputJsonPair(output, "nodeIndex", nodeIndex_);
OutputJsonPair(output, "reversed", reverseCaller_);
}
OutputJsonMapList(output, "callStack", childrenMap);
if (fprintf(output, "}") < 0) {
return;
}
}
uint64_t UpdateChildrenEventCount()
{
subTreeEventCount_ = selfEventCount_;
for (auto &pair : childrenMap) {
subTreeEventCount_ += pair.second.UpdateChildrenEventCount();
if (!funcName_.empty()) {
}
}
return subTreeEventCount_;
}
static bool FindByFunctionId(ReportCallNodeItem &a, int functionId)
{
return (a.functionId_ == functionId);
}
explicit ReportCallNodeItem(int functionId) : functionId_(functionId) {}
};
struct ReportLibItem {
int libId_ = 0;
uint64_t eventCount_ = 0;
std::map<int, ReportFuncItem> funcs_;
void OutputJson(FILE *output) const
{
if (fprintf(output, "{") < 0) {
return;
}
OutputJsonPair(output, "fileId", libId_, true);
OutputJsonPair(output, "eventCount", eventCount_);
OutputJsonMapList(output, "functions", funcs_);
if (fprintf(output, "}") < 0) {
return;
}
}
};
struct ReportThreadItem {
pid_t tid_ = 0;
uint64_t eventCount_ = 0;
uint64_t sampleCount_ = 0;
std::map<int, ReportLibItem> libs_;
ReportCallNodeItem callNode;
ReportCallNodeItem callNodeReverse;
void OutputJson(FILE *output) const
{
if (fprintf(output, "{") < 0) {
return;
}
OutputJsonPair(output, "tid", tid_, true);
OutputJsonPair(output, "eventCount", eventCount_);
OutputJsonPair(output, "sampleCount", sampleCount_);
OutputJsonMapList(output, "libs", libs_);
OutputJsonPair(output, "CallOrder", callNode);
OutputJsonPair(output, "CalledOrder", callNodeReverse);
if (fprintf(output, "}") < 0) {
return;
}
}
ReportThreadItem(pid_t id) : tid_(id), callNode(-1), callNodeReverse(-1) {}
};
struct ReportProcessItem {
pid_t pid_ = 0;
uint64_t eventCount_ = 0;
std::map<pid_t, ReportThreadItem> threads_;
void OutputJson(FILE *output) const
{
if (fprintf(output, "{") < 0) {
return;
}
OutputJsonPair(output, "pid", pid_, true);
OutputJsonPair(output, "eventCount", eventCount_);
OutputJsonMapList(output, "threads", threads_);
if (fprintf(output, "}") < 0) {
return;
}
}
explicit ReportProcessItem(pid_t pid) : pid_(pid) {}
};
struct ReportConfigItem {
int index_;
std::string eventName_;
uint64_t eventCount_ = 0;
std::map<pid_t, ReportProcessItem> processes_;
void OutputJson(FILE *output) const
{
if (fprintf(output, "{") < 0) {
return;
}
OutputJsonPair(output, "eventConfigName", eventName_, true);
OutputJsonPair(output, "eventCount", eventCount_);
OutputJsonMapList(output, "processes", processes_);
if (fprintf(output, "}") < 0) {
return;
}
}
ReportConfigItem(int index, std::string eventName) : index_(index), eventName_(eventName) {}
};
using functionKey = std::tuple<int, std::string_view>;
static constexpr const int keyLibId = 0;
static constexpr const int keyfuncName = 1;
class ReportJsonFile {
public:
int nodeIndex_ = 0; // debug only
static bool debug_;
FILE *output_ = nullptr;
ReportJsonFile(const std::unique_ptr<PerfFileReader> &recordFileReader,
const VirtualRuntime &virtualRuntime)
: recordFileReader_(recordFileReader), virtualRuntime_(virtualRuntime)
{
}
void UpdateReportSample(uint64_t configid, pid_t pid, pid_t tid, uint64_t eventCount);
void UpdateReportCallStack(uint64_t id, pid_t pid, pid_t tid, uint64_t eventCount,
std::vector<CallFrame> &frames);
void UpdateCallNodeEventCount();
void ProcessSymbolsFiles(const std::vector<std::unique_ptr<SymbolsFile>> &symbolsFiles);
// json
bool OutputJson(FILE *output = nullptr);
std::map<std::vector<uint64_t>, ReportConfigItem> reportConfigItems_;
private:
const std::unique_ptr<PerfFileReader> &recordFileReader_;
const VirtualRuntime &virtualRuntime_;
std::vector<std::string_view> libList_;
std::vector<functionKey> functionList_;
std::map<int, ReportFuncMapItem> functionMap_;
void addNewFunction(int libId, std::string_view name);
ReportConfigItem &GetConfig(uint64_t id);
std::string GetConfigName(uint64_t id);
uint32_t GetConfigIndex(uint64_t id);
int GetFuncionID(int libId, std::string_view function);
int GetLibID(std::string_view filepath);
void OutputJsonFeatureString();
void OutputJsonRuntimeInfo();
void AddReportCallStack(uint64_t eventCount, ReportCallNodeItem &callNode,
const std::vector<CallFrame> &frames);
void AddReportCallStackReverse(uint64_t eventCount, ReportCallNodeItem &callNode,
const std::vector<CallFrame> &frames);
uint64_t sampleCount_ = 0;
FRIEND_TEST(ReportJsonFileTest, UpdateReportSample);
FRIEND_TEST(ReportJsonFileTest, UpdateReportCallStack);
FRIEND_TEST(ReportJsonFileTest, UpdateCallNodeEventCount);
FRIEND_TEST(ReportJsonFileTest, ProcessSymbolsFiles);
FRIEND_TEST(ReportJsonFileTest, GetFuncionID);
FRIEND_TEST(ReportJsonFileTest, GetLibID);
FRIEND_TEST(ReportJsonFileTest, GetConfigIndex);
FRIEND_TEST(ReportJsonFileTest, GetConfigName);
FRIEND_TEST(ReportJsonFileTest, GetConfig);
friend class ReportJsonFileTest;
};
} // namespace HiPerf
} // namespace Developtools
} // namespace OHOS
#endif // REPORT_JSON_FILE_H
Reference in New Issue View Git Blame Copy Permalink