chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,16 @@
|
||||
cc_test(
|
||||
test_event_node
|
||||
SRCS test_event_node.cc
|
||||
DEPS event_node profiler_logger)
|
||||
cc_test(
|
||||
test_extra_info
|
||||
SRCS test_extra_info.cc
|
||||
DEPS phi glog common)
|
||||
cc_test(
|
||||
test_serialization_logger
|
||||
SRCS dump/test_serialization_logger.cc
|
||||
DEPS event_bind)
|
||||
cc_test(
|
||||
new_profiler_test
|
||||
SRCS profiler_test.cc
|
||||
DEPS new_profiler)
|
||||
@@ -0,0 +1,315 @@
|
||||
// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
|
||||
//
|
||||
// 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 "gtest/gtest.h"
|
||||
#include "paddle/fluid/framework/type_defs.h"
|
||||
#include "paddle/fluid/platform/profiler/dump/deserialization_reader.h"
|
||||
#include "paddle/fluid/platform/profiler/dump/serialization_logger.h"
|
||||
#include "paddle/fluid/platform/profiler/event_node.h"
|
||||
#include "paddle/fluid/platform/profiler/event_python.h"
|
||||
|
||||
using paddle::framework::AttributeMap;
|
||||
using paddle::platform::DeserializationReader;
|
||||
using paddle::platform::DeviceTraceEvent;
|
||||
using paddle::platform::HostTraceEvent;
|
||||
using paddle::platform::HostTraceEventNode;
|
||||
using paddle::platform::KernelEventInfo;
|
||||
using paddle::platform::MemcpyEventInfo;
|
||||
using paddle::platform::MemsetEventInfo;
|
||||
using paddle::platform::MemTraceEvent;
|
||||
using paddle::platform::NodeTrees;
|
||||
using paddle::platform::OperatorSupplementEvent;
|
||||
using paddle::platform::RuntimeTraceEvent;
|
||||
using paddle::platform::SerializationLogger;
|
||||
using phi::TracerEventType;
|
||||
using phi::TracerMemEventType;
|
||||
|
||||
TEST(SerializationLoggerTest, dump_case0) {
|
||||
std::list<HostTraceEvent> host_events;
|
||||
std::list<RuntimeTraceEvent> runtime_events;
|
||||
std::list<DeviceTraceEvent> device_events;
|
||||
std::list<MemTraceEvent> mem_events;
|
||||
std::list<OperatorSupplementEvent> op_supplement_events;
|
||||
host_events.emplace_back(std::string("dataloader#1"),
|
||||
TracerEventType::Dataloader,
|
||||
1000,
|
||||
10000,
|
||||
10,
|
||||
10);
|
||||
host_events.emplace_back(
|
||||
std::string("op1"), TracerEventType::Operator, 11000, 20000, 10, 10);
|
||||
host_events.emplace_back(
|
||||
std::string("op2"), TracerEventType::Operator, 21000, 30000, 10, 10);
|
||||
host_events.emplace_back(
|
||||
std::string("op3"), TracerEventType::Operator, 31000, 40000, 10, 11);
|
||||
mem_events.emplace_back(11500,
|
||||
0x1000,
|
||||
TracerMemEventType::Allocate,
|
||||
10,
|
||||
10,
|
||||
50,
|
||||
"GPU:0",
|
||||
50,
|
||||
50,
|
||||
100,
|
||||
100);
|
||||
mem_events.emplace_back(11900,
|
||||
0x1000,
|
||||
TracerMemEventType::Free,
|
||||
10,
|
||||
10,
|
||||
-50,
|
||||
"GPU:0",
|
||||
0,
|
||||
50,
|
||||
100,
|
||||
100);
|
||||
std::map<std::string, std::vector<std::vector<int64_t>>> input_shapes;
|
||||
std::map<std::string, std::vector<std::string>> dtypes;
|
||||
input_shapes[std::string("X")].push_back(std::vector<int64_t>{1, 2, 3});
|
||||
input_shapes[std::string("X")].push_back(std::vector<int64_t>{4, 5, 6, 7});
|
||||
dtypes[std::string("X")].emplace_back("int8");
|
||||
dtypes[std::string("X")].emplace_back("float32");
|
||||
AttributeMap attrs;
|
||||
op_supplement_events.emplace_back(
|
||||
11600, "op1", input_shapes, dtypes, "op1()", attrs, 0, 10, 10);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch1"), 15000, 17000, 10, 10, 1, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch2"), 25000, 35000, 10, 10, 2, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch3"), 33000, 37000, 10, 11, 3, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemcpy1"), 18000, 19000, 10, 10, 4, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemset1"), 38000, 39000, 10, 11, 5, 0);
|
||||
device_events.emplace_back(std::string("kernel1"),
|
||||
TracerEventType::Kernel,
|
||||
40000,
|
||||
55000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
1,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel2"),
|
||||
TracerEventType::Kernel,
|
||||
70000,
|
||||
95000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
2,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel3"),
|
||||
TracerEventType::Kernel,
|
||||
60000,
|
||||
65000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
3,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("memcpy1"),
|
||||
TracerEventType::Memcpy,
|
||||
56000,
|
||||
59000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
4,
|
||||
MemcpyEventInfo());
|
||||
device_events.emplace_back(std::string("memset1"),
|
||||
TracerEventType::Memset,
|
||||
66000,
|
||||
69000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
5,
|
||||
MemsetEventInfo());
|
||||
SerializationLogger logger("test_serialization_logger_case0.pb");
|
||||
logger.LogMetaInfo(std::string("1.0.2"), 0);
|
||||
NodeTrees tree(host_events,
|
||||
runtime_events,
|
||||
device_events,
|
||||
mem_events,
|
||||
op_supplement_events);
|
||||
std::map<uint64_t, std::vector<HostTraceEventNode*>> nodes =
|
||||
tree.Traverse(true);
|
||||
EXPECT_EQ(nodes[10].size(), 4u);
|
||||
EXPECT_EQ(nodes[11].size(), 2u);
|
||||
std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
|
||||
std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
|
||||
for (auto& thread1_node : thread1_nodes) {
|
||||
if (thread1_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 3u);
|
||||
}
|
||||
if (thread1_node->Name() == "op1") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
EXPECT_EQ(thread1_node->GetMemTraceEventNodes().size(), 2u);
|
||||
EXPECT_NE(thread1_node->GetOperatorSupplementEventNode(), nullptr);
|
||||
}
|
||||
}
|
||||
for (auto& thread2_node : thread2_nodes) {
|
||||
if (thread2_node->Name() == "op3") {
|
||||
EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
}
|
||||
}
|
||||
tree.LogMe(&logger);
|
||||
logger.LogExtraInfo(std::unordered_map<std::string, std::string>());
|
||||
}
|
||||
|
||||
TEST(SerializationLoggerTest, dump_case1) {
|
||||
std::list<HostTraceEvent> host_events;
|
||||
std::list<RuntimeTraceEvent> runtime_events;
|
||||
std::list<DeviceTraceEvent> device_events;
|
||||
std::list<MemTraceEvent> mem_events;
|
||||
std::list<OperatorSupplementEvent> op_supplement_events;
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch1"), 15000, 17000, 10, 10, 1, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch2"), 25000, 35000, 10, 10, 2, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch3"), 33000, 37000, 10, 11, 3, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemcpy1"), 18000, 19000, 10, 10, 4, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemset1"), 38000, 39000, 10, 11, 5, 0);
|
||||
device_events.emplace_back(std::string("kernel1"),
|
||||
TracerEventType::Kernel,
|
||||
40000,
|
||||
55000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
1,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel2"),
|
||||
TracerEventType::Kernel,
|
||||
70000,
|
||||
95000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
2,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel3"),
|
||||
TracerEventType::Kernel,
|
||||
60000,
|
||||
65000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
3,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("memcpy1"),
|
||||
TracerEventType::Memcpy,
|
||||
56000,
|
||||
59000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
4,
|
||||
MemcpyEventInfo());
|
||||
device_events.emplace_back(std::string("memset1"),
|
||||
TracerEventType::Memset,
|
||||
66000,
|
||||
69000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
5,
|
||||
MemsetEventInfo());
|
||||
SerializationLogger logger("test_serialization_logger_case1.pb");
|
||||
logger.LogMetaInfo(std::string("1.0.2"), 0);
|
||||
NodeTrees tree(host_events,
|
||||
runtime_events,
|
||||
device_events,
|
||||
mem_events,
|
||||
op_supplement_events);
|
||||
std::map<uint64_t, std::vector<HostTraceEventNode*>> nodes =
|
||||
tree.Traverse(true);
|
||||
EXPECT_EQ(nodes[10].size(), 1u);
|
||||
EXPECT_EQ(nodes[11].size(), 1u);
|
||||
std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
|
||||
std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
|
||||
for (auto& thread1_node : thread1_nodes) {
|
||||
if (thread1_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 3u);
|
||||
}
|
||||
}
|
||||
for (auto& thread2_node : thread2_nodes) {
|
||||
if (thread2_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
}
|
||||
}
|
||||
tree.LogMe(&logger);
|
||||
logger.LogExtraInfo(std::unordered_map<std::string, std::string>());
|
||||
}
|
||||
|
||||
TEST(DeserializationReaderTest, restore_case0) {
|
||||
DeserializationReader reader("test_serialization_logger_case0.pb");
|
||||
auto profiler_result = reader.Parse();
|
||||
auto tree = profiler_result->GetNodeTrees();
|
||||
std::map<uint64_t, std::vector<HostTraceEventNode*>> nodes =
|
||||
tree->Traverse(true);
|
||||
EXPECT_EQ(nodes[10].size(), 4u);
|
||||
EXPECT_EQ(nodes[11].size(), 2u);
|
||||
std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
|
||||
std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
|
||||
for (auto& thread1_node : thread1_nodes) {
|
||||
if (thread1_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 3u);
|
||||
}
|
||||
if (thread1_node->Name() == "op1") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
EXPECT_EQ(thread1_node->GetMemTraceEventNodes().size(), 2u);
|
||||
EXPECT_NE(thread1_node->GetOperatorSupplementEventNode(), nullptr);
|
||||
}
|
||||
}
|
||||
for (auto& thread2_node : thread2_nodes) {
|
||||
if (thread2_node->Name() == "op3") {
|
||||
EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(DeserializationReaderTest, restore_case1) {
|
||||
DeserializationReader reader("test_serialization_logger_case1.pb");
|
||||
auto profiler_result = reader.Parse();
|
||||
auto tree = profiler_result->GetNodeTrees();
|
||||
std::map<uint64_t, std::vector<HostTraceEventNode*>> nodes =
|
||||
tree->Traverse(true);
|
||||
EXPECT_EQ(nodes[10].size(), 1u);
|
||||
EXPECT_EQ(nodes[11].size(), 1u);
|
||||
std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
|
||||
std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
|
||||
for (auto& thread1_node : thread1_nodes) {
|
||||
if (thread1_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 3u);
|
||||
}
|
||||
}
|
||||
for (auto& thread2_node : thread2_nodes) {
|
||||
if (thread2_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
|
||||
//
|
||||
// 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 <set>
|
||||
#include <string>
|
||||
|
||||
#include "glog/logging.h"
|
||||
#include "gtest/gtest.h"
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
#include <cuda.h>
|
||||
#endif
|
||||
#ifdef PADDLE_WITH_HIP
|
||||
#include <hip/hip_runtime.h>
|
||||
#endif
|
||||
#include "paddle/fluid/platform/profiler/event_python.h"
|
||||
#include "paddle/fluid/platform/profiler/profiler.h"
|
||||
#include "paddle/phi/common/place.h"
|
||||
#include "paddle/phi/core/platform/profiler.h"
|
||||
#include "paddle/phi/core/platform/profiler/event_tracing.h"
|
||||
|
||||
TEST(ProfilerTest, TestHostTracer) {
|
||||
using paddle::platform::Profiler;
|
||||
using paddle::platform::ProfilerOptions;
|
||||
using paddle::platform::ProfilerResult;
|
||||
using paddle::platform::RecordInstantEvent;
|
||||
using phi::TracerEventType;
|
||||
ProfilerOptions options;
|
||||
options.trace_level = 2;
|
||||
options.trace_switch = 3;
|
||||
auto profiler = Profiler::Create(options);
|
||||
EXPECT_TRUE(profiler);
|
||||
profiler->Prepare();
|
||||
profiler->Start();
|
||||
{
|
||||
RecordInstantEvent(
|
||||
"TestTraceLevel_record1", TracerEventType::UserDefined, 2);
|
||||
RecordInstantEvent(
|
||||
"TestTraceLevel_record2", TracerEventType::UserDefined, 3);
|
||||
}
|
||||
auto profiler_result = profiler->Stop();
|
||||
auto nodetree = profiler_result->GetNodeTrees();
|
||||
std::set<std::string> host_events;
|
||||
for (const auto& pair : nodetree->Traverse(true)) {
|
||||
for (const auto evt : pair.second) {
|
||||
host_events.insert(evt->Name());
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(host_events.count("TestTraceLevel_record1"), 1u);
|
||||
EXPECT_EQ(host_events.count("TestTraceLevel_record2"), 0u);
|
||||
}
|
||||
|
||||
TEST(ProfilerTest, TestCudaTracer) {
|
||||
using paddle::platform::Profiler;
|
||||
using paddle::platform::ProfilerOptions;
|
||||
using paddle::platform::ProfilerResult;
|
||||
ProfilerOptions options;
|
||||
options.trace_level = 0;
|
||||
options.trace_switch = 3;
|
||||
auto profiler = Profiler::Create(options);
|
||||
EXPECT_TRUE(profiler);
|
||||
profiler->Prepare();
|
||||
profiler->Start();
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
cudaStream_t stream;
|
||||
cudaStreamCreate(&stream);
|
||||
cudaStreamSynchronize(stream);
|
||||
#endif
|
||||
#ifdef PADDLE_WITH_HIP
|
||||
hipStream_t stream;
|
||||
hipStreamCreate(&stream);
|
||||
hipStreamSynchronize(stream);
|
||||
#endif
|
||||
auto profiler_result = profiler->Stop();
|
||||
auto nodetree = profiler_result->GetNodeTrees();
|
||||
std::vector<std::string> runtime_events;
|
||||
for (const auto& pair : nodetree->Traverse(true)) {
|
||||
for (const auto host_node : pair.second) {
|
||||
for (auto runtime_node : host_node->GetRuntimeTraceEventNodes()) {
|
||||
runtime_events.push_back(runtime_node->Name());
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef PADDLE_WITH_CUPTI
|
||||
#ifndef PADDLE_WITH_XPU
|
||||
EXPECT_GT(runtime_events.size(), 0u);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST(ProfilerTest, TestHostTracerForMem) {
|
||||
using paddle::platform::EnableHostEventRecorder;
|
||||
using paddle::platform::MemTraceEventNode;
|
||||
using paddle::platform::Profiler;
|
||||
using paddle::platform::ProfilerOptions;
|
||||
using paddle::platform::ProfilerResult;
|
||||
using paddle::platform::RecordInstantEvent;
|
||||
using paddle::platform::RecordMemEvent;
|
||||
using phi::CPUPlace;
|
||||
using phi::RecordEvent;
|
||||
using phi::TracerEventType;
|
||||
using phi::TracerMemEventType;
|
||||
ProfilerOptions options;
|
||||
options.trace_level = 1;
|
||||
options.trace_switch = 3;
|
||||
auto profiler = Profiler::Create(options);
|
||||
EXPECT_TRUE(profiler);
|
||||
EnableHostEventRecorder();
|
||||
profiler->Prepare();
|
||||
profiler->Start();
|
||||
{
|
||||
RecordEvent event1(
|
||||
"TestTracerForMem_phase1", TracerEventType::UserDefined, 1);
|
||||
RecordMemEvent(reinterpret_cast<void*>(0),
|
||||
CPUPlace(),
|
||||
1024,
|
||||
TracerMemEventType::Allocate);
|
||||
RecordMemEvent(
|
||||
reinterpret_cast<void*>(0), CPUPlace(), 1024, TracerMemEventType::Free);
|
||||
}
|
||||
{
|
||||
RecordEvent event2(
|
||||
"TestTracerForMem_phase2", TracerEventType::UserDefined, 1);
|
||||
RecordMemEvent(reinterpret_cast<void*>(1024),
|
||||
CPUPlace(),
|
||||
1024,
|
||||
TracerMemEventType::Allocate);
|
||||
RecordMemEvent(reinterpret_cast<void*>(1024),
|
||||
CPUPlace(),
|
||||
1024,
|
||||
TracerMemEventType::Free);
|
||||
}
|
||||
auto profiler_result = profiler->Stop();
|
||||
auto nodetree = profiler_result->GetNodeTrees();
|
||||
}
|
||||
@@ -0,0 +1,390 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
|
||||
//
|
||||
// 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 "gtest/gtest.h"
|
||||
#include "paddle/fluid/framework/type_defs.h"
|
||||
#include "paddle/fluid/platform/profiler/chrometracing_logger.h"
|
||||
#include "paddle/fluid/platform/profiler/event_node.h"
|
||||
|
||||
using paddle::framework::AttributeMap;
|
||||
using paddle::platform::ChromeTracingLogger;
|
||||
using paddle::platform::CudaRuntimeTraceEventNode;
|
||||
using paddle::platform::DeviceTraceEvent;
|
||||
using paddle::platform::DeviceTraceEventNode;
|
||||
using paddle::platform::HostTraceEvent;
|
||||
using paddle::platform::HostTraceEventNode;
|
||||
using paddle::platform::KernelEventInfo;
|
||||
using paddle::platform::MemcpyEventInfo;
|
||||
using paddle::platform::MemsetEventInfo;
|
||||
using paddle::platform::MemTraceEvent;
|
||||
using paddle::platform::MemTraceEventNode;
|
||||
using paddle::platform::NodeTrees;
|
||||
using paddle::platform::OperatorSupplementEvent;
|
||||
using paddle::platform::OperatorSupplementEventNode;
|
||||
using paddle::platform::RuntimeTraceEvent;
|
||||
using phi::TracerEventType;
|
||||
using phi::TracerMemEventType;
|
||||
|
||||
TEST(NodeTreesTest, LogMe_case0) {
|
||||
std::list<HostTraceEvent> host_events;
|
||||
std::list<RuntimeTraceEvent> runtime_events;
|
||||
std::list<DeviceTraceEvent> device_events;
|
||||
std::list<MemTraceEvent> mem_events;
|
||||
std::list<OperatorSupplementEvent> op_supplement_events;
|
||||
host_events.emplace_back(std::string("dataloader#1"),
|
||||
TracerEventType::Dataloader,
|
||||
1000,
|
||||
10000,
|
||||
10,
|
||||
10);
|
||||
host_events.emplace_back(
|
||||
std::string("op1"), TracerEventType::Operator, 11000, 20000, 10, 10);
|
||||
host_events.emplace_back(
|
||||
std::string("op2"), TracerEventType::Operator, 21000, 30000, 10, 10);
|
||||
host_events.emplace_back(
|
||||
std::string("op3"), TracerEventType::Operator, 31000, 40000, 10, 11);
|
||||
mem_events.emplace_back(11500,
|
||||
0x1000,
|
||||
TracerMemEventType::Allocate,
|
||||
10,
|
||||
10,
|
||||
50,
|
||||
"GPU:0",
|
||||
50,
|
||||
50,
|
||||
100,
|
||||
100);
|
||||
mem_events.emplace_back(11900,
|
||||
0x1000,
|
||||
TracerMemEventType::Free,
|
||||
10,
|
||||
10,
|
||||
-50,
|
||||
"GPU:0",
|
||||
0,
|
||||
50,
|
||||
100,
|
||||
100);
|
||||
std::map<std::string, std::vector<std::vector<int64_t>>> input_shapes;
|
||||
std::map<std::string, std::vector<std::string>> dtypes;
|
||||
input_shapes[std::string("X")].push_back(std::vector<int64_t>{1, 2, 3});
|
||||
input_shapes[std::string("X")].push_back(std::vector<int64_t>{4, 5, 6, 7});
|
||||
dtypes[std::string("X")].emplace_back("int8");
|
||||
dtypes[std::string("X")].emplace_back("float32");
|
||||
AttributeMap attrs;
|
||||
op_supplement_events.emplace_back(
|
||||
11600, "op1", input_shapes, dtypes, "op1()", attrs, 0, 10, 10);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch1"), 15000, 17000, 10, 10, 1, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch2"), 25000, 35000, 10, 10, 2, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch3"), 33000, 37000, 10, 11, 3, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemcpy1"), 18000, 19000, 10, 10, 4, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemset1"), 38000, 39000, 10, 11, 5, 0);
|
||||
device_events.emplace_back(std::string("kernel1"),
|
||||
TracerEventType::Kernel,
|
||||
40000,
|
||||
55000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
1,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel2"),
|
||||
TracerEventType::Kernel,
|
||||
70000,
|
||||
95000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
2,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel3"),
|
||||
TracerEventType::Kernel,
|
||||
60000,
|
||||
65000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
3,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("memcpy1"),
|
||||
TracerEventType::Memcpy,
|
||||
56000,
|
||||
59000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
4,
|
||||
MemcpyEventInfo());
|
||||
device_events.emplace_back(std::string("memset1"),
|
||||
TracerEventType::Memset,
|
||||
66000,
|
||||
69000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
5,
|
||||
MemsetEventInfo());
|
||||
ChromeTracingLogger logger("test_nodetrees_logme_case0.json");
|
||||
logger.LogMetaInfo(std::string("1.0.2"), 0);
|
||||
NodeTrees tree(host_events,
|
||||
runtime_events,
|
||||
device_events,
|
||||
mem_events,
|
||||
op_supplement_events);
|
||||
std::map<uint64_t, std::vector<HostTraceEventNode*>> nodes =
|
||||
tree.Traverse(true);
|
||||
EXPECT_EQ(nodes[10].size(), 4u);
|
||||
EXPECT_EQ(nodes[11].size(), 2u);
|
||||
std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
|
||||
std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
|
||||
for (auto& thread1_node : thread1_nodes) {
|
||||
if (thread1_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 3u);
|
||||
}
|
||||
if (thread1_node->Name() == "op1") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
EXPECT_EQ(thread1_node->GetMemTraceEventNodes().size(), 2u);
|
||||
EXPECT_NE(thread1_node->GetOperatorSupplementEventNode(), nullptr);
|
||||
}
|
||||
}
|
||||
for (auto& thread2_node : thread2_nodes) {
|
||||
if (thread2_node->Name() == "op3") {
|
||||
EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
}
|
||||
}
|
||||
tree.LogMe(&logger);
|
||||
logger.LogExtraInfo(std::unordered_map<std::string, std::string>());
|
||||
}
|
||||
|
||||
TEST(NodeTreesTest, LogMe_case1) {
|
||||
std::list<HostTraceEvent> host_events;
|
||||
std::list<RuntimeTraceEvent> runtime_events;
|
||||
std::list<DeviceTraceEvent> device_events;
|
||||
std::list<MemTraceEvent> mem_events;
|
||||
std::list<OperatorSupplementEvent> op_supplement_events;
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch1"), 15000, 17000, 10, 10, 1, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch2"), 25000, 35000, 10, 10, 2, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch3"), 33000, 37000, 10, 11, 3, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemcpy1"), 18000, 19000, 10, 10, 4, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudaMemset1"), 38000, 39000, 10, 11, 5, 0);
|
||||
device_events.emplace_back(std::string("kernel1"),
|
||||
TracerEventType::Kernel,
|
||||
40000,
|
||||
55000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
1,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel2"),
|
||||
TracerEventType::Kernel,
|
||||
70000,
|
||||
95000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
2,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel3"),
|
||||
TracerEventType::Kernel,
|
||||
60000,
|
||||
65000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
3,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("memcpy1"),
|
||||
TracerEventType::Memcpy,
|
||||
56000,
|
||||
59000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
4,
|
||||
MemcpyEventInfo());
|
||||
device_events.emplace_back(std::string("memset1"),
|
||||
TracerEventType::Memset,
|
||||
66000,
|
||||
69000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
5,
|
||||
MemsetEventInfo());
|
||||
ChromeTracingLogger logger("test_nodetrees_logme_case1.json");
|
||||
logger.LogMetaInfo(std::string("1.0.2"), 0);
|
||||
NodeTrees tree(host_events,
|
||||
runtime_events,
|
||||
device_events,
|
||||
mem_events,
|
||||
op_supplement_events);
|
||||
std::map<uint64_t, std::vector<HostTraceEventNode*>> nodes =
|
||||
tree.Traverse(true);
|
||||
EXPECT_EQ(nodes[10].size(), 1u);
|
||||
EXPECT_EQ(nodes[11].size(), 1u);
|
||||
std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
|
||||
std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
|
||||
for (auto& thread1_node : thread1_nodes) {
|
||||
if (thread1_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 3u);
|
||||
}
|
||||
}
|
||||
for (auto& thread2_node : thread2_nodes) {
|
||||
if (thread2_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 2u);
|
||||
}
|
||||
}
|
||||
tree.LogMe(&logger);
|
||||
logger.LogExtraInfo(std::unordered_map<std::string, std::string>());
|
||||
}
|
||||
|
||||
TEST(NodeTreesTest, HandleTrees_case0) {
|
||||
std::list<HostTraceEvent> host_events;
|
||||
std::list<RuntimeTraceEvent> runtime_events;
|
||||
std::list<DeviceTraceEvent> device_events;
|
||||
std::list<MemTraceEvent> mem_events;
|
||||
std::list<OperatorSupplementEvent> op_supplement_events;
|
||||
host_events.emplace_back(
|
||||
std::string("op1"), TracerEventType::Operator, 10000, 100000, 10, 10);
|
||||
host_events.emplace_back(
|
||||
std::string("op2"), TracerEventType::Operator, 30000, 70000, 10, 10);
|
||||
host_events.emplace_back(
|
||||
std::string("op3"), TracerEventType::Operator, 2000, 120000, 10, 11);
|
||||
mem_events.emplace_back(11500,
|
||||
0x1000,
|
||||
TracerMemEventType::Allocate,
|
||||
10,
|
||||
10,
|
||||
50,
|
||||
"GPU:0",
|
||||
50,
|
||||
50,
|
||||
100,
|
||||
100);
|
||||
mem_events.emplace_back(11900,
|
||||
0x1000,
|
||||
TracerMemEventType::Free,
|
||||
10,
|
||||
10,
|
||||
-50,
|
||||
"GPU:0",
|
||||
0,
|
||||
50,
|
||||
100,
|
||||
100);
|
||||
AttributeMap attrs;
|
||||
op_supplement_events.emplace_back(
|
||||
11600,
|
||||
"op1",
|
||||
std::map<std::string, std::vector<std::vector<int64_t>>>(),
|
||||
std::map<std::string, std::vector<std::string>>(),
|
||||
"op1()",
|
||||
attrs,
|
||||
0,
|
||||
10,
|
||||
10);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch1"), 15000, 25000, 10, 10, 1, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch2"), 35000, 45000, 10, 10, 2, 0);
|
||||
runtime_events.emplace_back(
|
||||
std::string("cudalaunch3"), 10000, 55000, 10, 11, 3, 0);
|
||||
device_events.emplace_back(std::string("kernel1"),
|
||||
TracerEventType::Kernel,
|
||||
40000,
|
||||
55000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
1,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel2"),
|
||||
TracerEventType::Kernel,
|
||||
70000,
|
||||
95000,
|
||||
0,
|
||||
10,
|
||||
10,
|
||||
2,
|
||||
KernelEventInfo());
|
||||
device_events.emplace_back(std::string("kernel3"),
|
||||
TracerEventType::Kernel,
|
||||
60000,
|
||||
75000,
|
||||
0,
|
||||
10,
|
||||
11,
|
||||
3,
|
||||
KernelEventInfo());
|
||||
ChromeTracingLogger logger("test_nodetrees_handletrees_case0.json");
|
||||
logger.LogMetaInfo(std::string("1.0.2"), 0);
|
||||
NodeTrees tree(host_events,
|
||||
runtime_events,
|
||||
device_events,
|
||||
mem_events,
|
||||
op_supplement_events);
|
||||
std::map<uint64_t, std::vector<HostTraceEventNode*>> nodes =
|
||||
tree.Traverse(true);
|
||||
EXPECT_EQ(nodes[10].size(), 3u);
|
||||
EXPECT_EQ(nodes[11].size(), 2u);
|
||||
std::vector<HostTraceEventNode*> thread1_nodes = nodes[10];
|
||||
std::vector<HostTraceEventNode*> thread2_nodes = nodes[11];
|
||||
for (auto& thread1_node : thread1_nodes) {
|
||||
if (thread1_node->Name() == "root node") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 1u);
|
||||
}
|
||||
if (thread1_node->Name() == "op1") {
|
||||
EXPECT_EQ(thread1_node->GetChildren().size(), 1u);
|
||||
EXPECT_EQ(thread1_node->GetRuntimeTraceEventNodes().size(), 1u);
|
||||
}
|
||||
}
|
||||
for (auto& thread2_node : thread2_nodes) {
|
||||
if (thread2_node->Name() == "op3") {
|
||||
EXPECT_EQ(thread2_node->GetChildren().size(), 0u);
|
||||
EXPECT_EQ(thread2_node->GetRuntimeTraceEventNodes().size(), 1u);
|
||||
}
|
||||
}
|
||||
std::function<void(HostTraceEventNode*)> host_event_node_handle(
|
||||
[&](HostTraceEventNode* a) { logger.LogHostTraceEventNode(*a); });
|
||||
std::function<void(CudaRuntimeTraceEventNode*)> runtime_event_node_handle(
|
||||
[&](CudaRuntimeTraceEventNode* a) {
|
||||
logger.LogRuntimeTraceEventNode(*a);
|
||||
});
|
||||
std::function<void(DeviceTraceEventNode*)> device_event_node_handle(
|
||||
[&](DeviceTraceEventNode* a) { logger.LogDeviceTraceEventNode(*a); });
|
||||
std::function<void(MemTraceEventNode*)> mem_event_node_handle(
|
||||
[&](MemTraceEventNode* a) { logger.LogMemTraceEventNode(*a); });
|
||||
std::function<void(OperatorSupplementEventNode*)>
|
||||
op_supplement_event_node_handle([&](OperatorSupplementEventNode* a) {});
|
||||
tree.HandleTrees(host_event_node_handle,
|
||||
runtime_event_node_handle,
|
||||
device_event_node_handle,
|
||||
mem_event_node_handle,
|
||||
op_supplement_event_node_handle);
|
||||
logger.LogExtraInfo(std::unordered_map<std::string, std::string>());
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
|
||||
//
|
||||
// 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 "gtest/gtest.h"
|
||||
#include "paddle/phi/core/platform/profiler/extra_info.h"
|
||||
|
||||
using paddle::platform::ExtraInfo;
|
||||
|
||||
TEST(ExtraInfoTest, case0) {
|
||||
ExtraInfo instance;
|
||||
instance.AddExtraInfo(std::string("info1"), std::string("%d"), 20);
|
||||
instance.AddExtraInfo(std::string("info2"), std::string("%s"), "helloworld");
|
||||
std::unordered_map<std::string, std::string> map = instance.GetExtraInfo();
|
||||
EXPECT_EQ(map["info1"], "20");
|
||||
EXPECT_EQ(map["info2"], "helloworld");
|
||||
EXPECT_EQ(map.size(), 2u);
|
||||
instance.Clear();
|
||||
map = instance.GetExtraInfo();
|
||||
EXPECT_EQ(map.size(), 0u);
|
||||
}
|
||||
Reference in New Issue
Block a user