278 lines
14 KiB
C++
278 lines
14 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "TimerGroupingAndSorting.h"
|
|
|
|
#include "Insights/Table/ViewModels/TableColumn.h"
|
|
#include "Insights/ViewModels/TimerNodeHelper.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "TimerNode"
|
|
|
|
// Sort by name (ascending).
|
|
#define INSIGHTS_DEFAULT_SORTING_NODES(A, B) return A->GetName().LexicalLess(B->GetName());
|
|
// #define INSIGHTS_DEFAULT_SORTING_NODES(A, B) return A->GetDefaultSortOrder() < B->GetDefaultSortOrder();
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Sorting by Timer Type
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FTimerNodeSortingByTimerType::FTimerNodeSortingByTimerType(TSharedRef<Insights::FTableColumn> InColumnRef)
|
|
: Insights::FTableCellValueSorter(
|
|
FName(TEXT("ByTimerType")),
|
|
LOCTEXT("Sorting_ByTimerType_Name", "By Type"),
|
|
LOCTEXT("Sorting_ByTimerType_Title", "Sort By Type"),
|
|
LOCTEXT("Sorting_ByTimerType_Desc", "Sort by timer type."),
|
|
InColumnRef)
|
|
{
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FTimerNodeSortingByTimerType::Sort(TArray<Insights::FBaseTreeNodePtr>& NodesToSort, Insights::ESortMode SortMode) const
|
|
{
|
|
if (SortMode == Insights::ESortMode::Ascending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
|
|
if (TimerNodeA->GetType() == TimerNodeB->GetType())
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by timer type (ascending).
|
|
return TimerNodeA->GetType() < TimerNodeB->GetType();
|
|
}
|
|
});
|
|
}
|
|
else // if (SortMode == ESortMode::Descending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
|
|
if (TimerNodeA->GetType() == TimerNodeB->GetType())
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by timer type (descending).
|
|
return TimerNodeB->GetType() < TimerNodeA->GetType();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Sort by Instance Count
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FTimerNodeSortingByInstanceCount::FTimerNodeSortingByInstanceCount(TSharedRef<Insights::FTableColumn> InColumnRef)
|
|
: Insights::FTableCellValueSorter(
|
|
FName(TEXT("ByInstanceCount")),
|
|
LOCTEXT("Sorting_ByInstanceCount_Name", "By Instance Count"),
|
|
LOCTEXT("Sorting_ByInstanceCount_Title", "Sort By Instance Count"),
|
|
LOCTEXT("Sorting_ByInstanceCount_Desc", "Sort by aggregated instance count."),
|
|
InColumnRef)
|
|
{
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FTimerNodeSortingByInstanceCount::Sort(TArray<Insights::FBaseTreeNodePtr>& NodesToSort, Insights::ESortMode SortMode) const
|
|
{
|
|
if (SortMode == Insights::ESortMode::Ascending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
const uint64 ValueA = TimerNodeA->GetAggregatedStats().InstanceCount;
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
const uint64 ValueB = TimerNodeB->GetAggregatedStats().InstanceCount;
|
|
|
|
if (ValueA == ValueB)
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by instance count (ascending).
|
|
return ValueA < ValueB;
|
|
}
|
|
});
|
|
}
|
|
else // if (SortMode == ESortMode::Descending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
const uint64 ValueA = TimerNodeA->GetAggregatedStats().InstanceCount;
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
const uint64 ValueB = TimerNodeB->GetAggregatedStats().InstanceCount;
|
|
|
|
if (ValueA == ValueB)
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by instance count (descending).
|
|
return ValueB < ValueA;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Sort by Total Inclusive Time
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FTimerNodeSortingByTotalInclusiveTime::FTimerNodeSortingByTotalInclusiveTime(TSharedRef<Insights::FTableColumn> InColumnRef)
|
|
: Insights::FTableCellValueSorter(
|
|
FName(TEXT("ByTotalInclusiveTime")),
|
|
LOCTEXT("Sorting_ByTotalInclusiveTime_Name", "By Total Inclusive Time"),
|
|
LOCTEXT("Sorting_ByTotalInclusiveTime_Title", "Sort By Total Inclusive Time"),
|
|
LOCTEXT("Sorting_ByTotalInclusiveTime_Desc", "Sort by aggregated total inclusive time."),
|
|
InColumnRef)
|
|
{
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FTimerNodeSortingByTotalInclusiveTime::Sort(TArray<Insights::FBaseTreeNodePtr>& NodesToSort, Insights::ESortMode SortMode) const
|
|
{
|
|
if (SortMode == Insights::ESortMode::Ascending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
const double ValueA = TimerNodeA->GetAggregatedStats().TotalInclusiveTime;
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
const double ValueB = TimerNodeB->GetAggregatedStats().TotalInclusiveTime;
|
|
|
|
if (ValueA == ValueB)
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by total inclusive time (ascending).
|
|
return ValueA < ValueB;
|
|
}
|
|
});
|
|
}
|
|
else // if (SortMode == ESortMode::Descending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
const double ValueA = TimerNodeA->GetAggregatedStats().TotalInclusiveTime;
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
const double ValueB = TimerNodeB->GetAggregatedStats().TotalInclusiveTime;
|
|
|
|
if (ValueA == ValueB)
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by total inclusive time (descending).
|
|
return ValueB < ValueA;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Sort by Total Exclusive Time
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FTimerNodeSortingByTotalExclusiveTime::FTimerNodeSortingByTotalExclusiveTime(TSharedRef<Insights::FTableColumn> InColumnRef)
|
|
: Insights::FTableCellValueSorter(
|
|
FName(TEXT("ByTotalExclusiveTime")),
|
|
LOCTEXT("Sorting_ByTotalExclusiveTime_Name", "By Total Exclusive Time"),
|
|
LOCTEXT("Sorting_ByTotalExclusiveTime_Title", "Sort By Total Exclusive Time"),
|
|
LOCTEXT("Sorting_ByTotalExclusiveTime_Desc", "Sort by aggregated total exclusive time."),
|
|
InColumnRef)
|
|
{
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FTimerNodeSortingByTotalExclusiveTime::Sort(TArray<Insights::FBaseTreeNodePtr>& NodesToSort, Insights::ESortMode SortMode) const
|
|
{
|
|
if (SortMode == Insights::ESortMode::Ascending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
const double ValueA = TimerNodeA->GetAggregatedStats().TotalExclusiveTime;
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
const double ValueB = TimerNodeB->GetAggregatedStats().TotalExclusiveTime;
|
|
|
|
if (ValueA == ValueB)
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by total exclusive time (ascending).
|
|
return ValueA < ValueB;
|
|
}
|
|
});
|
|
}
|
|
else // if (SortMode == ESortMode::Descending)
|
|
{
|
|
NodesToSort.Sort([](const Insights::FBaseTreeNodePtr& A, const Insights::FBaseTreeNodePtr& B) -> bool
|
|
{
|
|
ensure(A.IsValid() && A->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeA = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(A);
|
|
const double ValueA = TimerNodeA->GetAggregatedStats().TotalExclusiveTime;
|
|
|
|
ensure(B.IsValid() && B->GetTypeName() == FTimerNode::TypeName);
|
|
const FTimerNodePtr TimerNodeB = StaticCastSharedPtr<FTimerNode, Insights::FBaseTreeNode>(B);
|
|
const double ValueB = TimerNodeB->GetAggregatedStats().TotalExclusiveTime;
|
|
|
|
if (ValueA == ValueB)
|
|
{
|
|
INSIGHTS_DEFAULT_SORTING_NODES(A, B)
|
|
}
|
|
else
|
|
{
|
|
// Sort by total exclusive time (descending).
|
|
return ValueB < ValueA;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#undef INSIGHTS_DEFAULT_SORTING_NODES
|
|
#undef LOCTEXT_NAMESPACE
|