C++ NodeSet::Filter方法代码示例

void NodeCapacitySubspace::GetTargetNodesForReplicas(
    TempSolution const& tempSolution,
    std::vector<PlacementReplica const*> const& replicas,
    NodeSet & candidateNodes,
    bool useNodeBufferCapacity,
    NodeToConstraintDiagnosticsDataMapSPtr const nodeToConstraintDiagnosticsDataMapSPtr /* = nullptr */) const
{
    ASSERT_IF(replicas.size() == 0, "Replica empty.");
    NodeEntry const* currentNode = replicas.size() == 1 ? tempSolution.GetReplicaLocation(replicas[0]) : nullptr;

    //Choose the function here to avoid the runtime speeed hit of boolean checks for every node in the filter
    auto FilterCandidateNodesForCapacityConstraintsWithOrWithoutDiagnostics = (nodeToConstraintDiagnosticsDataMapSPtr == nullptr) ?
            static_cast<std::function<bool(NodeEntry const *)>>(
                [&](NodeEntry const *node) -> bool
                {
                    return FilterCandidateNodesForCapacityConstraints(node, tempSolution, replicas, useNodeBufferCapacity, false);
                }
            ):
            static_cast<std::function<bool(NodeEntry const *)>>(
                [&](NodeEntry const *node) -> bool
                {
                    NodeCapacityViolationDiagnosticsDataSPtr constraintDiagnosticsDataSPtr =
                        make_shared<NodeCapacityViolationDiagnosticsData>(L"", 0, 0, 0, 0, 0, 0, false);

                    return FilterCandidateNodesForCapacityConstraints(node,
                        tempSolution,
                        replicas,
                        useNodeBufferCapacity,
                        constraintDiagnosticsDataSPtr, false) ? true :
                            [&node, &nodeToConstraintDiagnosticsDataMapSPtr, &constraintDiagnosticsDataSPtr]() -> bool
                            {
                                nodeToConstraintDiagnosticsDataMapSPtr->insert(move(std::pair<Federation::NodeId, NodeCapacityViolationDiagnosticsDataSPtr>(node->NodeId, move(constraintDiagnosticsDataSPtr))));  // with diagnostics
                                return false;
                            }();
                }
            );

    candidateNodes.Filter([&](NodeEntry const *node) -> bool
    {
        if (!node->HasCapacity)
        {
            return true;
        }
        else if (node == currentNode)
        {
            auto itNode = nodeExtraLoads_.find(currentNode);
            if (itNode != nodeExtraLoads_.end())
            {
                auto itReplica = itNode->second.find(replicas[0]);
                if (itReplica != itNode->second.end())
                {
                    // if the replica is one of invalid replicas on this node
                    return false;
                }
            }

            return true;
        }
        else if (replicas[0]->Partition->Service->Application
                 && replicas[0]->Partition->Service->Application->HasReservation)
        {
            // If replica was already on this node, it will be allowed to return because it will be evaluated in the previous
            // else-if branch above. Here we check if application was on this node, and we don't allow new replicas from that app.
            // This won't happen during search for upgrade (replicas.size() > 1), so we're safe checking replicas[0]
            auto const& nodeIt = nodeExtraApplications_.find(node);
            if (   nodeIt != nodeExtraApplications_.end()
                && nodeIt->second.find(replicas[0]->Partition->Service->Application) != nodeIt->second.end())
            {
                // We are moving the entire application from this node, so it's not allowed as target. If we had allowed it, and if 
                // replica load was below reservation then there is no other mechanism for ensuring that application will be moved.
                return false;
            }
            return FilterCandidateNodesForCapacityConstraintsWithOrWithoutDiagnostics(node);
        }
        else if (replicas[0]->Partition->Service->ServicePackage)
        {
            // This won't happen during search for upgrade (replicas.size() > 1), so we're safe checking replicas[0]
            auto const& nodeIt = nodeExtraServicePackages_.find(node);
            if (   nodeIt != nodeExtraServicePackages_.end()
                && nodeIt->second.find(replicas[0]->Partition->Service->ServicePackage) != nodeIt->second.end())
            {
                // We are moving the entire service package from this node, so it's not allowed as target. If we had allowed it, and if 
                // replica load was below reservation then there is no other mechanism for ensuring that application will be moved.
                return false;
            }
            return FilterCandidateNodesForCapacityConstraintsWithOrWithoutDiagnostics(node);
        }
        else
        {
            return FilterCandidateNodesForCapacityConstraintsWithOrWithoutDiagnostics(node);
        }
    });
}

void NodeCapacitySubspace::PromoteSecondaryForPartitions(TempSolution const& tempSolution, std::vector<PartitionEntry const*> const& partitions, NodeSet & candidateNodes) const
{

    size_t globalMetricCount = tempSolution.OriginalPlacement->GlobalMetricCount;
    size_t totalMetricCount = tempSolution.OriginalPlacement->TotalMetricCount;
    ASSERT_IFNOT(totalMetricCount >= globalMetricCount, "Invalid metric count");
    size_t globalMetricStartIndex = totalMetricCount - globalMetricCount;

    bool applyOnlyMoveInChanges = tempSolution.OriginalPlacement->Settings.PreventTransientOvercommit;

    candidateNodes.Filter([&](NodeEntry const *node) -> bool
    {
        if (!node->IsUp)
        {
            return false;
        }
        if (!node->HasCapacity)
        {
            return true;
        }
        else
        {
            LoadEntry const& originalLoads = node->Loads;
            LoadEntry const& shouldDisappearLoads = node->ShouldDisappearLoads;
            LoadEntry const& baseLoads = tempSolution.BaseSolution.NodeChanges[node];
            LoadEntry const& tempLoads = applyOnlyMoveInChanges ? tempSolution.NodeMovingInChanges[node] : tempSolution.NodeChanges[node];

            ASSERT_IFNOT(totalMetricCount == originalLoads.Length && totalMetricCount == tempLoads.Length &&
                totalMetricCount == baseLoads.Length, "Invalid temp loads or base loads");

            bool ret = true;
            LoadEntry swapLoadDiffEntry(globalMetricCount);

            // We rely on static subspace to filter out nodes without secondaries, so we assume that there are replicas on the node.
            std::map<ApplicationEntry const*, LoadEntry> appLoadOnNode;

            for (auto pIt = partitions.begin(); pIt != partitions.end(); ++pIt)
            {
                auto partition = *pIt;
                ServiceEntry const* replicaService = partition->Service;
                ApplicationEntry const* application = replicaService->Application;
                bool hasReservation = application && application->HasReservation;

                std::map<ApplicationEntry const*, LoadEntry>::iterator appLoadOnNodeIt;

                if (hasReservation)
                {
                    appLoadOnNodeIt = appLoadOnNode.find(application);
                    if (appLoadOnNodeIt == appLoadOnNode.end())
                    {
                        appLoadOnNodeIt = appLoadOnNode.insert(make_pair(application, ((NodeMetrics const&)tempSolution.ApplicationNodeLoad[application])[node])).first;
                    }
                }

                LoadEntry const& primaryEntry = partition->GetReplicaEntry(ReplicaRole::Primary);
                LoadEntry const& secondaryEntry = partition->GetReplicaEntry(ReplicaRole::Secondary, true, node->NodeId);

                for (size_t metricIndex = 0; metricIndex < replicaService->MetricCount; metricIndex++)
                {
                    ASSERT_IFNOT(metricIndex < secondaryEntry.Length,
                        "Metric index should be < replica entry size: {0} {1}",
                        metricIndex,
                        secondaryEntry.Length);

                    int64 swapLoadDiffValue = primaryEntry.Values[metricIndex] - secondaryEntry.Values[metricIndex];

                    size_t globalMetricIndex = replicaService->GlobalMetricIndices[metricIndex];
                    size_t capacityIndex = globalMetricIndex - globalMetricStartIndex;

                    if (hasReservation)
                    {
                        // There are already replicas on the node: this replica may fit into reservation that already exists
                        auto applicationLoadOnNode =  appLoadOnNodeIt->second.Values[capacityIndex];
                        appLoadOnNodeIt->second.AddLoad(capacityIndex, swapLoadDiffValue);
                        auto applicationReservation = application->Reservation.Values[capacityIndex];
                        auto remainingReservation = applicationLoadOnNode < applicationReservation ? applicationReservation - applicationLoadOnNode : 0;
                        swapLoadDiffValue = swapLoadDiffValue < remainingReservation ? 0 : swapLoadDiffValue - remainingReservation;
                    }

                    swapLoadDiffEntry.AddLoad(capacityIndex, swapLoadDiffValue);
                }
            }

            for (size_t i = 0; i < globalMetricCount; ++i)
            {
                int64 partitionsSwapDiffValue = swapLoadDiffEntry.Values[i];
                int64 capacity = node->TotalCapacities.Values[i];

                if (partitionsSwapDiffValue <= 0 || capacity < 0)
                {
                    continue;
                }

                size_t totalIndex = globalMetricStartIndex + i;

                int64 totalLoadWithPartitionsSwap = originalLoads.Values[totalIndex] +
                    tempSolution.GetApplicationReservedLoad(node, i) +
                    shouldDisappearLoads.Values[totalIndex] +
                    tempLoads.Values[totalIndex] +
                    partitionsSwapDiffValue;
//.........这里部分代码省略.........