OpenHarmony-v4.1-Release/s

/*
 * 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.
 */
#include "htrace_mem_parser.h"
#include "clock_filter_ex.h"
#include "htrace_event_parser.h"
#include "measure_filter.h"
#include "memory_plugin_common.pbreader.h"
#include "memory_plugin_config.pbreader.h"
#include "memory_plugin_result.pbreader.h"
#include "process_filter.h"
#include "stat_filter.h"
#include "system_event_measure_filter.h"

namespace SysTuning {
namespace TraceStreamer {
std::vector<std::string> g_unknownAnonMemInfo = {
    "[anon]",
    "[anon:libwebview reservation]",
    "[anon:atexit handlers]",
    "[anon:cfi shadow]",
    "[anon:thread signal stack]",
    "[anon:bionic_alloc_small_objects]",
    "[anon:bionic_alloc_lob]",
    "[anon:linker_alloc]",
    "[anon:System property context nodes]",
    "[anon:arc4random data]",
};
std::map<std::string, uint32_t> g_checkMemStart = {
    {"[stack", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_STACK},
    {"[anon:stack_and_tls:", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_STACK},
    {"[anon:stack:", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_STACK},
    {"[anon:signal_stack:", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_STACK},
    {"[anon:maple_alloc_ros]", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:dalvik-allocspace", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:dalvik-main space", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:dalvik-large object", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:dalvik-free list large", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:dalvik-non moving", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:dalvik-zygote space", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:dalvik-", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JAVA_VM},
    {"/dev/ashmem/jit-zygote-cache", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JAVA_VM},
    {"/memfd:jit-cache", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JAVA_VM},
    {"/memfd:jit-zygote-cache", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JAVA_VM},
    {"[heap]", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP},
    {"[anon:libc_malloc", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP},
    {"[anon:scudo", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP},
    {"[anon:GWP-Asan", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP},
};
std::map<std::string, uint32_t> g_checkMemEnd = {
    {".art", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {".art]", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {".tty", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_FONT},
};
std::map<std::string, uint32_t> g_checkMemContain = {
    {"[anon:ArkJS Heap]", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_JS_HEAP},
    {"[anon:native_heap:jemalloc]", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP},
    {"[heap]", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP},
    {"[anon:native_heap:musl]", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP},
    {"/dev/ashmem/", (uint32_t)HtraceMemParser::SmapsMemType::SMAPS_MEM_TYPE_ASHMEM},
};
HtraceMemParser::HtraceMemParser(TraceDataCache* dataCache, const TraceStreamerFilters* ctx)
    : EventParserBase(dataCache, ctx)
{
    for (auto i = 0; i < MEM_MAX; i++) {
        memNameDictMap_.insert(
            std::make_pair(static_cast<MemInfoType>(i),
                           traceDataCache_->GetDataIndex(config_.memNameMap_.at(static_cast<MemInfoType>(i)))));
    }
    for (auto i = 0; i < ProtoReader::PMEM_PINED_PURG + 1; i++) {
        sysMemNameDictMap_.insert(std::make_pair(i, traceDataCache_->GetDataIndex(config_.sysMemNameMap_.at(i))));
    }
    for (auto i = 0; i < ProtoReader::VMEMINFO_WORKINGSET_RESTORE + 1; i++) {
        sysVMemNameDictMap_.insert(
            std::make_pair(i, traceDataCache_->GetDataIndex(config_.sysVirtualMemNameMap_.at(i))));
    }
}

HtraceMemParser::~HtraceMemParser()
{
    TS_LOGI("mem ts MIN:%llu, MAX:%llu", static_cast<unsigned long long>(GetPluginStartTime()),
            static_cast<unsigned long long>(GetPluginEndTime()));
}
void HtraceMemParser::Parse(HtraceDataSegment& seg, uint64_t timeStamp, BuiltinClocks clock)
{
    ProtoReader::MemoryData_Reader memData(seg.protoData.data_, seg.protoData.size_);
    auto newTimeStamp = streamFilters_->clockFilter_->ToPrimaryTraceTime(clock, timeStamp);
    UpdatePluginTimeRange(clock, timeStamp, newTimeStamp);
    zram_ = memData.zram();
    gpuLimit_ = memData.has_gpu_limit_size() ? memData.gpu_limit_size() : 0;
    gpuUsed_ = memData.has_gpu_used_size() ? memData.gpu_used_size() : 0;
    if (memData.has_processesinfo()) {
        ParseProcessInfo(&memData, newTimeStamp);
    }
    if (memData.has_meminfo()) {
        ParseMemInfo(&memData, newTimeStamp);
    }
    if (memData.has_vmeminfo()) {
        ParseVMemInfo(&memData, newTimeStamp);
    }
    if (memData.has_ashmeminfo()) {
        ParseAshmemInfo(&memData, newTimeStamp);
    }
    if (memData.has_dmainfo()) {
        ParseDmaMemInfo(&memData, newTimeStamp);
    }
    if (memData.has_gpumemoryinfo()) {
        ParseGpuProcessMemInfo(&memData, newTimeStamp);
    }
    if (memData.has_gpudumpinfo()) {
        ParseGpuWindowMemInfo(&memData, newTimeStamp);
    }
    if (memData.has_windowinfo()) {
        ParseWindowManagerServiceInfo(&memData, newTimeStamp);
    }
    if (memData.has_cpudumpinfo()) {
        ParseCpuDumpInfo(&memData, newTimeStamp);
    }
    if (memData.has_profilememinfo()) {
        ParseProfileMemInfo(&memData, newTimeStamp);
    }
    if (memData.has_rsdumpinfo()) {
        ParseRSImageDumpInfo(&memData, newTimeStamp);
    }
}

void HtraceMemParser::SpecialDataAddition(ProtoReader::ProcessMemoryInfo_Reader& processMemoryInfo,
                                          uint64_t timeStamp,
                                          uint32_t ipid,
                                          uint32_t hasValue) const
{
    // processMemoryInfo Special data addition
    if (processMemoryInfo.has_purg_sum_kb()) {
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_PURG_SUM), timeStamp, processMemoryInfo.purg_sum_kb());
    }
    if (processMemoryInfo.has_purg_pin_kb()) {
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_PURG_PIN), timeStamp, processMemoryInfo.purg_pin_kb());
    }
    if (processMemoryInfo.has_gl_pss_kb()) {
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_GL_PSS), timeStamp, processMemoryInfo.gl_pss_kb());
    }
    if (processMemoryInfo.has_graph_pss_kb()) {
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_GRAPH_PSS), timeStamp, processMemoryInfo.graph_pss_kb());
    }
    if (hasValue) {
        streamFilters_->processFilter_->AddProcessMemory(ipid);
    }
    if (processMemoryInfo.has_smapinfo()) {
        ParseSmapsInfoEasy(&processMemoryInfo, timeStamp, ipid);
    }
}

void HtraceMemParser::ParseProcessInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    if (tracePacket->has_processesinfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_MEMORY, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->processesinfo(); i; ++i) {
        ProtoReader::ProcessMemoryInfo_Reader processMemoryInfo(i->ToBytes().data_, i->ToBytes().size_);
        auto ipid = streamFilters_->processFilter_->UpdateOrCreateProcessWithName(
            processMemoryInfo.pid(), processMemoryInfo.name().ToStdString());
        uint32_t hasValue = 0;
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_VM_SIZE), timeStamp, processMemoryInfo.vm_size_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_VM_RSS), timeStamp, processMemoryInfo.vm_rss_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_VM_ANON), timeStamp, processMemoryInfo.rss_anon_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_RSS_FILE), timeStamp, processMemoryInfo.rss_file_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_RSS_SHMEM), timeStamp, processMemoryInfo.rss_shmem_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_VM_SWAP), timeStamp, processMemoryInfo.vm_swap_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_VM_LOCKED), timeStamp, processMemoryInfo.vm_locked_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_VM_HWM), timeStamp, processMemoryInfo.vm_hwm_kb());
        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
            ipid, memNameDictMap_.at(MEM_OOM_SCORE_ADJ), timeStamp, processMemoryInfo.oom_score_adj());

        SpecialDataAddition(processMemoryInfo, timeStamp, ipid, hasValue);
    }
}
uint32_t HtraceMemParser::ParseSmapsPathTypeByPrefix(bool hasX, const std::string& path, const bool hasAppName) const
{
    if (EndWith(path, ".so")) {
        if (hasX) {
            if (StartWith(path, "/data/app/") || hasAppName) {
                return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_CODE_APP);
            } else {
                return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_CODE_SYS);
            }
        } else {
            if (StartWith(path, "[anon:.bss]/data/app/") || StartWith(path, "/data/app/") || hasAppName) {
                return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP);
            } else {
                return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS);
            }
        }
    }
    return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_INVALID);
}
uint32_t HtraceMemParser::ParseSmapsPathTypeBySuffix(bool hasX, const std::string& path, const bool hasAppName) const
{
    if ((EndWith(path, ".jar")) || (EndWith(path, ".apk")) || (EndWith(path, ".vdex")) || (EndWith(path, ".odex")) ||
        (EndWith(path, ".oat")) || (path.find("dex") != std::string::npos)) {
        return hasX ? (hasAppName ? static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_CODE_APP)
                                  : static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_CODE_SYS))
                    : (hasAppName ? static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP)
                                  : static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS));
    }
    return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_INVALID);
}

uint32_t HtraceMemParser::ParseSmapsBlockDetail(ProtoReader::SmapsInfo_Reader& smapsInfo,
                                                const std::string& path,
                                                const bool hasAppName) const
{
    bool hasX = smapsInfo.permission().ToStdString().find("x") != std::string::npos;
    auto type = ParseSmapsPathTypeByPrefix(hasX, path, hasAppName);
    if (type != static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_INVALID)) {
        return type;
    }
    type = ParseSmapsPathTypeBySuffix(hasX, path, hasAppName);
    if (type != static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_INVALID)) {
        return type;
    }
    if (hasX && path.find("/bin/") != std::string::npos) {
        return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_CODE_SYS);
    }
    if ((!hasX) && (path.find("/bin/") != std::string::npos || path.find("[anon:.bss]") != std::string::npos)) {
        return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS);
    }
    if (path.find("[bss]") != std::string::npos) {
        return hasAppName ? static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_DATA_APP)
                          : static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_DATA_SYS);
    }
    if ((path.find("[anon]") != std::string::npos) || (path.find("[anon:") != std::string::npos)) {
        if (std::find(g_unknownAnonMemInfo.begin(), g_unknownAnonMemInfo.end(), path) != g_unknownAnonMemInfo.end()) {
            return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_UNKNOWN_ANON);
        }
        return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_NATIVE_HEAP);
    }
    return static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_INVALID);
}

uint32_t HtraceMemParser::ParseSmapsBlockType(ProtoReader::SmapsInfo_Reader& smapsInfo) const
{
    std::string path(smapsInfo.path().ToStdString());
    path.erase(0, path.find_first_not_of(" "));
    path.erase(path.find_last_not_of(" ") + 1);
    if (path.empty()) {
        path = "[anon]";
    }
    for (const auto& iter : g_checkMemStart) {
        if (StartWith(path, iter.first)) {
            return iter.second;
        }
    }
    for (const auto& iter : g_checkMemEnd) {
        if (EndWith(path, iter.first)) {
            return iter.second;
        }
    }
    for (const auto& iter : g_checkMemContain) {
        if (path.find(iter.first) != std::string::npos) {
            return iter.second;
        }
    }
    bool hasAppName = path.find("com.huawei.wx") != std::string::npos;
    uint32_t detailRet = (smapsInfo, path, hasAppName);
    if (detailRet != static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_INVALID)) {
        return detailRet;
    }
    return hasAppName ? static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_OTHER_APP)
                      : static_cast<uint32_t>(SmapsMemType::SMAPS_MEM_TYPE_OTHER_SYS);
}

void HtraceMemParser::ParseSmapsInfoEasy(const ProtoReader::ProcessMemoryInfo_Reader* memInfo,
                                         uint64_t timeStamp,
                                         uint64_t ipid) const
{
    streamFilters_->statFilter_->IncreaseStat(TRACE_SMAPS, STAT_EVENT_RECEIVED);
    for (auto i = memInfo->smapinfo(); i; ++i) {
        ProtoReader::SmapsInfo_Reader smapsInfo(i->ToBytes().data_, i->ToBytes().size_);
        auto startAddr = "0x" + smapsInfo.start_addr().ToStdString();
        auto endAddr = "0x" + smapsInfo.end_addr().ToStdString();
        uint64_t dirty = smapsInfo.dirty();
        uint64_t swapper = smapsInfo.swapper();
        uint64_t rss = smapsInfo.rss();
        uint64_t pss = smapsInfo.pss();
        uint64_t size = smapsInfo.size();
        double reside = smapsInfo.reside();
        DataIndex protection = traceDataCache_->GetDataIndex(smapsInfo.permission().ToStdString());
        DataIndex path = traceDataCache_->GetDataIndex(smapsInfo.path().ToStdString());
        uint64_t privateClean = smapsInfo.has_private_clean() ? smapsInfo.private_clean() : 0;
        uint64_t privateDirty = smapsInfo.has_private_dirty() ? smapsInfo.private_dirty() : 0;
        uint64_t sharedClean = smapsInfo.has_shared_clean() ? smapsInfo.shared_clean() : 0;
        uint64_t sharedDirty = smapsInfo.has_shared_dirty() ? smapsInfo.shared_dirty() : 0;
        uint64_t swap = smapsInfo.has_swap() ? smapsInfo.swap() : 0;
        uint64_t swapPss = smapsInfo.has_swap_pss() ? smapsInfo.swap_pss() : 0;
        uint32 type = ParseSmapsBlockType(smapsInfo);
        traceDataCache_->GetSmapsData()->AppendNewData(timeStamp, ipid, startAddr, endAddr, dirty, swapper, rss, pss,
                                                       size, reside, protection, path, sharedClean, sharedDirty,
                                                       privateClean, privateDirty, swap, swapPss, type);
    }
}

void HtraceMemParser::ParseMemInfoEasy(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    if (tracePacket->has_meminfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->meminfo(); i; ++i) {
        ProtoReader::SysMeminfo_Reader sysMeminfo(i->ToBytes());
        if (config_.sysMemNameMap_.find(sysMeminfo.key()) != config_.sysMemNameMap_.end()) {
            streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData(sysMemNameDictMap_.at(sysMeminfo.key()),
                                                                             timeStamp, sysMeminfo.value());
        } else {
            streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_MEMORY, STAT_EVENT_DATA_INVALID);
        }
    }
}

void HtraceMemParser::ParseVMemInfoEasy(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    traceDataCache_->UpdateTraceTime(timeStamp);
    if (tracePacket->has_vmeminfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_VIRTUAL_MEMORY, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->vmeminfo(); i; ++i) {
        ProtoReader::SysVMeminfo_Reader sysVMeminfo(i->ToBytes());
        if (config_.sysVirtualMemNameMap_.find(sysVMeminfo.key()) != config_.sysVirtualMemNameMap_.end()) {
            streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData(sysVMemNameDictMap_.at(sysVMeminfo.key()),
                                                                             timeStamp, sysVMeminfo.value());
        } else {
            streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_VIRTUAL_MEMORY, STAT_EVENT_DATA_INVALID);
        }
    }
}

void HtraceMemParser::ParseMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED);
    for (auto i = tracePacket->meminfo(); i; ++i) {
        ProtoReader::SysMeminfo_Reader sysMeminfo(i->ToBytes());
        if (sysMeminfo.key() >= ProtoReader::PMEM_UNSPECIFIED && sysMeminfo.key() <= ProtoReader::PMEM_PINED_PURG) {
            streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData(sysMemNameDictMap_.at(sysMeminfo.key()),
                                                                            timeStamp, sysMeminfo.value());
        } else {
            streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_MEMORY, STAT_EVENT_DATA_INVALID);
        }
    }
    streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData(zramIndex_, timeStamp, zram_);
    streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData(gpuLimitSizeIndex_, timeStamp, gpuLimit_);
    streamFilters_->sysEventMemMeasureFilter_->AppendNewMeasureData(gpuUsedSizeIndex_, timeStamp, gpuUsed_);
}

void HtraceMemParser::ParseVMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_VIRTUAL_MEMORY, STAT_EVENT_RECEIVED);
    for (auto i = tracePacket->vmeminfo(); i; ++i) {
        ProtoReader::SysVMeminfo_Reader sysVMeminfo(i->ToBytes());
        if (sysVMeminfo.key() >= ProtoReader::VMEMINFO_UNSPECIFIED &&
            sysVMeminfo.key() <= ProtoReader::VMEMINFO_WORKINGSET_RESTORE) {
            streamFilters_->sysEventVMemMeasureFilter_->AppendNewMeasureData(sysVMemNameDictMap_.at(sysVMeminfo.key()),
                                                                             timeStamp, sysVMeminfo.value());
        } else {
            // case SysVMeminfoType_INT_MAX_SENTINEL_DO_NOT_USE_:
            streamFilters_->statFilter_->IncreaseStat(TRACE_SYS_VIRTUAL_MEMORY, STAT_EVENT_DATA_INVALID);
        }
    }
}
void HtraceMemParser::ParseAshmemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    if (tracePacket->has_ashmeminfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_ASHMEM, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->ashmeminfo(); i; ++i) {
        ProtoReader::AshmemInfo_Reader AshmemInfo(i->ToBytes().data_, i->ToBytes().size_);
        auto ipid = streamFilters_->processFilter_->UpdateOrCreateProcessWithName(AshmemInfo.pid(),
                                                                                  AshmemInfo.name().ToStdString());
        uint32_t adj = AshmemInfo.adj();
        uint32_t fd = AshmemInfo.fd();
        DataIndex ashmemNameId = traceDataCache_->GetDataIndex(AshmemInfo.ashmem_name().ToStdString());
        uint64_t size = AshmemInfo.size();
        uint32_t ashmemId = AshmemInfo.id();
        uint64_t time = AshmemInfo.time();
        uint64_t refCount = AshmemInfo.ref_count();
        uint64_t purged = AshmemInfo.purged();
        uint32_t flag = 0;
        uint64_t pss = 0;
        auto smapsData = traceDataCache_->GetConstSmapsData();
        auto smapsCount = smapsData.Size();
        for (auto j = 0; j < smapsCount; j++) {
            auto path = traceDataCache_->GetDataFromDict(smapsData.PathIds()[j]);
            if ((smapsData.Ipids()[j] == ipid) && (path.find("/dev/ashmem/") != std::string::npos)) {
                pss += smapsData.Pss()[j] + smapsData.SwapPss()[j];
            }
        }
        traceDataCache_->GetAshMemData()->AppendNewData(ipid, timeStamp, adj, fd, ashmemNameId, size, pss, ashmemId,
                                                        time, refCount, purged, flag);
    }
    AshMemDeduplicate();
}
void HtraceMemParser::AshMemDeduplicate() const
{
    auto ashMemData = traceDataCache_->GetAshMemData();
    auto ashMemCount = ashMemData->Size();
    if (ashMemCount <= 1) {
        return;
    }

    std::vector<std::pair<size_t, size_t>> dataByTs;
    size_t start = 0;
    auto ts = ashMemData->TimeStampData()[0];
    for (auto i = 0; i < ashMemCount; ++i) {
        auto tsTmp = ashMemData->TimeStampData()[i];
        if (tsTmp != ts) {
            dataByTs.emplace_back(std::make_pair(start, i - 1));
            start = i;
            ts = tsTmp;
        }
    }
    dataByTs.emplace_back(std::make_pair(start, ashMemCount - 1));

    for (const auto& iterator : dataByTs) {
        /* L1 map (key = id+time, value = L2 map)
           L2 map (key = ipid, value = index) */
        std::map<std::pair<uint32_t, uint64_t>, std::map<uint64_t, uint64_t>> AshMemMap;
        for (auto i = iterator.first; i <= iterator.second; ++i) {
            auto ashmemId = ashMemData->AshmemIds()[i];
            auto time = ashMemData->Times()[i];
            auto key = std::make_pair(ashmemId, time);
            auto ipid = ashMemData->Ipids()[i];
            auto& pidMap = AshMemMap[key];
            if (pidMap.find(ipid) == pidMap.end()) {
                pidMap.emplace(ipid, i);
            } else {
                ashMemData->SetFlag(i, (uint32_t)MemDeduplicateFlag::MEM_DEDUPLICATE_FLAG_DUP_SAME_PROCESS);
            }
        }

        for (const auto& item : AshMemMap) {
            auto& pidMap = item.second;
            auto iter = pidMap.begin();
            if (iter == pidMap.end()) {
                continue;
            }
            for (++iter; iter != pidMap.end(); ++iter) {
                ashMemData->SetFlag(iter->second, (uint32_t)MemDeduplicateFlag::MEM_DEDUPLICATE_FLAG_DUP_DIFF_PROCESS);
            }
        }
    }
}
HtraceMemParser::MemProcessType HtraceMemParser::GetMemProcessType(uint64_t ipid) const
{
    const auto& iterProcess = traceDataCache_->GetConstProcessData(ipid);
    if (iterProcess.cmdLine_ == "composer_host") {
        return MemProcessType::PID_TYPE_COMPOSER;
    } else if (iterProcess.cmdLine_ == "render_service") {
        return MemProcessType::PID_TYPE_RENDER_SERVICES;
    } else {
        return MemProcessType::PID_TYPE_APP;
    }
}

void HtraceMemParser::ParseDmaMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    if (tracePacket->has_dmainfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_DMAMEM, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->dmainfo(); i; ++i) {
        ProtoReader::DmaInfo_Reader DmaMemInfo(i->ToBytes().data_, i->ToBytes().size_);
        auto ipid = streamFilters_->processFilter_->UpdateOrCreateProcessWithName(DmaMemInfo.pid(),
                                                                                  DmaMemInfo.name().ToStdString());
        uint32_t fd = DmaMemInfo.fd();
        uint64_t size = DmaMemInfo.size();
        uint32_t ino = DmaMemInfo.ino();
        uint64_t expPid = DmaMemInfo.exp_pid();
        DataIndex expTaskCommId = traceDataCache_->GetDataIndex(DmaMemInfo.exp_task_comm().ToStdString());
        DataIndex bufNameId = traceDataCache_->GetDataIndex(DmaMemInfo.buf_name().ToStdString());
        DataIndex expNameId = traceDataCache_->GetDataIndex(DmaMemInfo.exp_name().ToStdString());
        uint32_t flag = 0;
        traceDataCache_->GetDmaMemData()->AppendNewData(ipid, timeStamp, fd, size, ino, expPid, expTaskCommId,
                                                        bufNameId, expNameId, flag);
    }
    DmaMemDeduplicate();
}
void HtraceMemParser::DmaMemDeduplicate() const
{
    auto dmaMemData = traceDataCache_->GetDmaMemData();
    auto dmaCount = dmaMemData->Size();
    if (dmaCount <= 1) {
        return;
    }

    std::vector<std::pair<size_t, size_t>> dataByTs;
    size_t start = 0;
    auto ts = dmaMemData->TimeStampData()[0];
    for (auto i = 0; i < dmaCount; ++i) {
        auto tsTmp = dmaMemData->TimeStampData()[i];
        if (tsTmp != ts) {
            dataByTs.emplace_back(std::make_pair(start, i - 1));
            start = i;
            ts = tsTmp;
        }
    }
    dataByTs.emplace_back(std::make_pair(start, dmaCount - 1));

    for (const auto& iterator : dataByTs) {
        /* L1 map (key = ino, value = L2 map)
           L2 map (key = ipid, value = pair(index, MemProcessType)) */
        std::map<uint32_t, std::map<uint64_t, std::pair<uint64_t, MemProcessType>>> inoMap;
        std::map<uint32_t /*ino*/, MemProcessType> processTypeMap;
        for (auto i = iterator.first; i <= iterator.second; ++i) {
            auto ino = dmaMemData->Inos()[i];
            auto ipid = dmaMemData->Ipids()[i];
            auto& pidMap = inoMap[ino];
            if (pidMap.find(ipid) != pidMap.end()) {
                dmaMemData->SetFlag(i, (uint32_t)MemDeduplicateFlag::MEM_DEDUPLICATE_FLAG_DUP_SAME_PROCESS);
            } else {
                auto processType = GetMemProcessType(ipid);
                pidMap.emplace(ipid, std::make_pair(i, processType));
                if (processTypeMap[ino] < processType) {
                    processTypeMap[ino] = processType;
                }
            }
        }

        for (const auto& item : inoMap) {
            auto maxPidType = processTypeMap[item.first];
            const auto& pidMap = item.second;
            for (const auto& pidItem : pidMap) {
                if (pidItem.second.second < maxPidType) {
                    dmaMemData->SetFlag(pidItem.second.first,
                                        (uint32_t)MemDeduplicateFlag::MEM_DEDUPLICATE_FLAG_DUP_DIFF_PROCESS);
                }
            }
        }
    }
}

void HtraceMemParser::ParseGpuProcessMemInfo(const ProtoReader::MemoryData_Reader* tracePacket,
                                             uint64_t timeStamp) const
{
    if (tracePacket->has_gpumemoryinfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_GPU_PROCESS_MEM, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->gpumemoryinfo(); i; ++i) {
        ProtoReader::GpuMemoryInfo_Reader GpuMemoryInfo(i->ToBytes().data_, i->ToBytes().size_);
        DataIndex gpuNameId = traceDataCache_->GetDataIndex(GpuMemoryInfo.gpu_name().ToStdString());
        uint64_t allGpuSize = GpuMemoryInfo.all_gpu_size();
        if (GpuMemoryInfo.has_gpu_process_info()) {
            for (auto j = GpuMemoryInfo.gpu_process_info(); j; ++j) {
                ProtoReader::GpuProcessInfo_Reader GpuProcessInfo(j->ToBytes().data_, j->ToBytes().size_);
                std::string addr = GpuProcessInfo.addr().ToStdString();
                uint32_t pid = GpuProcessInfo.pid();
                uint32_t tid = GpuProcessInfo.tid();
                auto itid = streamFilters_->processFilter_->GetOrCreateThreadWithPid(tid, pid);
                auto ipid = streamFilters_->processFilter_->GetOrCreateInternalPid(timeStamp, pid);
                uint64_t usedGpuSize = GpuProcessInfo.used_gpu_size();

                traceDataCache_->GetGpuProcessMemData()->AppendNewData(timeStamp, gpuNameId, allGpuSize, addr, ipid,
                                                                       itid, usedGpuSize);
            }
        }
    }
}
void HtraceMemParser::FillGpuWindowMemInfo(const ProtoReader::GpuDumpInfo_Reader& gpuDumpInfo, uint64_t timeStamp) const
{
    DataIndex windowNameId = traceDataCache_->GetDataIndex(gpuDumpInfo.window_name().ToStdString());
    uint64_t windowId = gpuDumpInfo.id();
    uint64_t purgeableSize = gpuDumpInfo.gpu_purgeable_size();
    for (auto i = gpuDumpInfo.gpu_detail_info(); i; ++i) {
        ProtoReader::GpuDetailInfo_Reader GpuDetailInfo(i->ToBytes().data_, i->ToBytes().size_);
        DataIndex moduleNameId = traceDataCache_->GetDataIndex(GpuDetailInfo.module_name().ToStdString());
        if (!GpuDetailInfo.has_gpu_sub_info()) {
            continue;
        }
        for (auto j = GpuDetailInfo.gpu_sub_info(); j; ++j) {
            ProtoReader::GpuSubInfo_Reader gpuSubInfo(j->ToBytes().data_, j->ToBytes().size_);
            DataIndex categoryNameId = traceDataCache_->GetDataIndex(gpuSubInfo.category_name().ToStdString());
            uint64_t size = gpuSubInfo.size();
            uint32_t entryNum = gpuSubInfo.entry_num();
            traceDataCache_->GetGpuWindowMemData()->AppendNewData(timeStamp, windowNameId, windowId, moduleNameId,
                                                                  categoryNameId, size, entryNum, purgeableSize);
        }
    }
}
void HtraceMemParser::ParseGpuWindowMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    if (tracePacket->has_gpudumpinfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_GPU_WINDOW_MEM, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->gpudumpinfo(); i; ++i) {
        ProtoReader::GpuDumpInfo_Reader GpuDumpInfo(i->ToBytes().data_, i->ToBytes().size_);
        if (!GpuDumpInfo.has_gpu_detail_info()) {
            continue;
        }
        FillGpuWindowMemInfo(GpuDumpInfo, timeStamp);
    }
}
void HtraceMemParser::ParseWindowManagerServiceInfo(const ProtoReader::MemoryData_Reader* tracePacket,
                                                    uint64_t timeStamp)
{
    if (tracePacket->has_windowinfo()) {
        streamFilters_->statFilter_->IncreaseStat(TRACE_WINDOW_MANAGER_SERVICE, STAT_EVENT_RECEIVED);
    }
    for (auto i = tracePacket->windowinfo(); i; ++i) {
        ProtoReader::WindowManagerServiceInfo_Reader windowInfo(i->ToBytes().data_, i->ToBytes().size_);
        if (!windowInfo.has_pid() || !windowInfo.has_window_name()) {
            continue;
        }
        auto windowNameId = traceDataCache_->GetDataIndex(windowInfo.window_name().ToStdString());
        auto ipid =
            streamFilters_->processFilter_->GetOrCreateInternalPid(timeStamp, static_cast<uint32_t>(windowInfo.pid()));
        windowIdToipidMap_.insert({windowNameId, ipid});
    }
}
void HtraceMemParser::ParseCpuDumpInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    for (auto i = tracePacket->cpudumpinfo(); i; ++i) {
        ProtoReader::CpuDumpInfo_Reader cpuDumpInfo(i->ToBytes().data_, i->ToBytes().size_);
        auto totalSize = cpuDumpInfo.total_cpu_memory_size();
        traceDataCache_->GetCpuDumpInfo()->AppendNewData(timeStamp, totalSize);
    }
}
void HtraceMemParser::ParseProfileMemInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    for (auto i = tracePacket->profilememinfo(); i; ++i) {
        ProtoReader::ProfileMemInfo_Reader profileMemInfo(i->ToBytes().data_, i->ToBytes().size_);
        auto channelIndex = traceDataCache_->GetDataIndex(profileMemInfo.channel().ToStdString());
        auto totalSize = profileMemInfo.total_memory_size();
        traceDataCache_->GetProfileMemInfo()->AppendNewData(timeStamp, channelIndex, totalSize);
    }
}

void HtraceMemParser::ParseRSImageDumpInfo(const ProtoReader::MemoryData_Reader* tracePacket, uint64_t timeStamp) const
{
    for (auto i = tracePacket->rsdumpinfo(); i; ++i) {
        ProtoReader::RSImageDumpInfo_Reader rsImageDumpInfo(i->ToBytes().data_, i->ToBytes().size_);
        auto size = rsImageDumpInfo.size();
        auto typeIndex = traceDataCache_->GetDataIndex(rsImageDumpInfo.type().ToStdString());
        InternalPid ipid = INVALID_IPID;
        if (rsImageDumpInfo.has_pid()) {
            ipid = streamFilters_->processFilter_->GetOrCreateInternalPid(timeStamp,
                                                                          static_cast<uint32_t>(rsImageDumpInfo.pid()));
        }
        auto surfaceNameIndex = traceDataCache_->GetDataIndex(rsImageDumpInfo.surface_name().ToStdString());
        traceDataCache_->GetRSImageDumpInfo()->AppendNewData(timeStamp, size, typeIndex, ipid, surfaceNameIndex);
    }
}
void HtraceMemParser::ParseMemoryConfig(HtraceDataSegment& seg)
{
    ProtoReader::MemoryConfig_Reader memConfigData(seg.protoData.data_, seg.protoData.size_);
    if (memConfigData.has_pid()) {
        bool parseError = false;
        auto itor = memConfigData.pid(&parseError);
        if (parseError) {
            TS_LOGE("Parse pid in MemoryConfig function failed!!!");
            return;
        }
        while (itor) {
            int32_t pid = *itor;
            auto ipid = streamFilters_->processFilter_->GetOrCreateInternalPid(seg.timeStamp, pid);
            traceDataCache_->GetTraceConfigData()->AppendNewData("memory_config", "ipid", std::to_string(ipid));
            itor++;
        }
    }
}

void HtraceMemParser::Finish()
{
    traceDataCache_->GetGpuWindowMemData()->RevicesIpid(windowIdToipidMap_);
    if (traceDataCache_->traceStartTime_ == INVALID_UINT64 || traceDataCache_->traceEndTime_ == 0) {
        traceDataCache_->MixTraceTime(GetPluginStartTime(), GetPluginEndTime());
    } else {
        TS_LOGI("mem data time is not updated, maybe this trace file has other data");
    }
}
} // namespace TraceStreamer
} // namespace SysTuning