[CASSANDRA-19412] delete useless collection:backPressureHosts in the sendToHintedReplicas to improve write performance

• Type: Improvement
• Status: Resolved
• Priority: Low
• Resolution: Fixed
• Fix Version/s: 4.0.13, 4.1.5, 5.0-rc1, 5.0, 5.1
• Component/s: Legacy/Local Write-Read Paths
• Change Category: Performance
• Complexity: Low Hanging Fruit
• Platform: All

Source Control Link

https://github.com/apache/cassandra/commit/8c4a58f035f0d52e36aaba5ae1cf04049ae3dd9c

Test and Documentation Plan

CI

• Assignee: Ling Mao
• Reporter: Ling Mao

Authors

Ling Mao

Reviewers

Brandon Williams, Maxwell Guo, Stefan Miklosovic

• Created: 20/Feb/24 06:57
• Updated: 26/Mar/24 10:38
• Resolved: 22/Feb/24 09:19

Description

Every normal write request will go through this method(sendToHintedReplicas). However, the list:backPressureHosts in the method has never been used functionally.

The backpressure was introduced by:

Support optional backpressure strategies at the coordinator
patch by Sergio Bossa; reviewed by Stefania Alborghetti for CASSANDRA-9318

d43b9ce5 Sergio Bossa <[e-mail]> on 2016/9/19 at 10:42 AM 

public static void sendToHintedEndpoints(final Mutation mutation,
                                             Iterable<InetAddress> targets,
                                             AbstractWriteResponseHandler<IMutation> responseHandler,
                                             String localDataCenter,
                                             Stage stage)
    throws OverloadedException
    {
        int targetsSize = Iterables.size(targets);
        // this dc replicas:
        Collection<InetAddress> localDc = null;
        // extra-datacenter replicas, grouped by dc
        Map<String, Collection<InetAddress>> dcGroups = null;
        // only need to create a Message for non-local writes
        MessageOut<Mutation> message = null;
        boolean insertLocal = false;
        ArrayList<InetAddress> endpointsToHint = null;
        List<InetAddress> backPressureHosts = null;
        for (InetAddress destination : targets)
        {
            checkHintOverload(destination);
            if (FailureDetector.instance.isAlive(destination))
            {
                if (canDoLocalRequest(destination))
                {
                    insertLocal = true;
                }
                else
                {
                    // belongs on a different server
                    if (message == null)
                        message = mutation.createMessage();
                    String dc = DatabaseDescriptor.getEndpointSnitch().getDatacenter(destination);
                    // direct writes to local DC or old Cassandra versions
                    // (1.1 knows how to forward old-style String message IDs; updated to int in 2.0)
                    if (localDataCenter.equals(dc))
                    {
                        if (localDc == null)
                            localDc = new ArrayList<>(targetsSize);
                        localDc.add(destination);
                    }
                    else
                    {
                        Collection<InetAddress> messages = (dcGroups != null) ? dcGroups.get(dc) : null;
                        if (messages == null)
                        {
                            messages = new ArrayList<>(3); // most DCs will have <= 3 replicas
                            if (dcGroups == null)
                                dcGroups = new HashMap<>();
                            dcGroups.put(dc, messages);
                        }
                        messages.add(destination);
                    }
                    if (backPressureHosts == null)
                        backPressureHosts = new ArrayList<>(targetsSize);
                    backPressureHosts.add(destination);
                }
            }
            else
            {
                if (shouldHint(destination))
                {
                    if (endpointsToHint == null)
                        endpointsToHint = new ArrayList<>(targetsSize);
                    endpointsToHint.add(destination);
                }
            }
        }
        if (backPressureHosts != null)
            MessagingService.instance().applyBackPressure(backPressureHosts, responseHandler.currentTimeout());
        if (endpointsToHint != null)
            submitHint(mutation, endpointsToHint, responseHandler);
        if (insertLocal)
            performLocally(stage, Optional.of(mutation), mutation::apply, responseHandler);
        if (localDc != null)
        {
            for (InetAddress destination : localDc)
                MessagingService.instance().sendRR(message, destination, responseHandler, true);
        }
        if (dcGroups != null)
        {
            // for each datacenter, send the message to one node to relay the write to other replicas
            for (Collection<InetAddress> dcTargets : dcGroups.values())
                sendMessagesToNonlocalDC(message, dcTargets, responseHandler);
        }
    } 

Now the backPressure related codes had been deleted in the codebase, and here maybe someone forgot to remove the collection: backPressureHosts. Removing it will save every write request to add a few items to a list to reduce the memory footprint

Issue Links

• links to: GitHub Pull Request #3114
• links to: GitHub Pull Request #3115
• links to: GitHub Pull Request #3116
• links to: GitHub Pull Request #3117