Optimize DataPlacement lookup by ReplicationParams

Avoid double lookup of the same DataPlacement in forNonLocalStrategyTokenRead and forNonLocalStrategyTokenWrite methods
Memorize hashCode value
Deduplicate ReplicationParams to use the same objects in DataPlacements and KeyspaceMetadata to use the fast == path in the equals

Patch by Dmitry Konstantinov; reviewed by TBD for CASSANDRA-20804

Author: netudima

src/java/org/apache/cassandra/cql3/statements/schema/CreateKeyspaceStatement.java

@@ -82,6 +82,13 @@ public Keyspaces apply(ClusterMetadata metadata)
         }
 
         KeyspaceMetadata keyspaceMetadata = KeyspaceMetadata.create(keyspaceName, attrs.asNewKeyspaceParams());
+        // we deduplicate ReplicationParams here to use the same objects in KeyspaceMetadata
+        // as we have as keys in metadata.placements to have a fast map lookup
+        // ReplicationParams are immutable, so it is a safe optimization
+        KeyspaceParams keyspaceParams = keyspaceMetadata.params;
+        ReplicationParams replicationParams = metadata.placements.deduplicateReplicationParams(keyspaceParams.replication);
+        keyspaceParams = keyspaceParams.withSwapped(replicationParams);
+        keyspaceMetadata = keyspaceMetadata.withSwapped(keyspaceParams);
 
         if (keyspaceMetadata.params.replication.klass.equals(LocalStrategy.class))
             throw ire("Unable to use given strategy class: LocalStrategy is reserved for internal use.");

src/java/org/apache/cassandra/locator/ReplicaLayout.java

@@ -31,6 +31,7 @@
 import org.apache.cassandra.schema.TableId;
 import org.apache.cassandra.service.reads.ReadCoordinator;
 import org.apache.cassandra.tcm.ClusterMetadata;
+import org.apache.cassandra.tcm.ownership.DataPlacement;
 import org.apache.cassandra.utils.FBUtilities;
 
 import java.util.Set;
@@ -238,8 +239,9 @@ public static ReplicaLayout.ForTokenWrite forTokenWriteLiveAndDown(ClusterMetada
         {
             // todo deduplicate so that "pending" contains "read - write",
             // which is a hack until we revisit how consistency level handles pending
-            natural = forNonLocalStrategyTokenRead(metadata, ks, token);
-            pending = forNonLocalStrategyTokenWrite(metadata, ks, token).without(natural.endpoints());
+            DataPlacement dataPlacement = metadata.placements.get(ks.params.replication);
+            natural = forNonLocalStrategyTokenRead(dataPlacement, token);
+            pending = forNonLocalStrategyTokenWrite(dataPlacement, token).without(natural.endpoints());
         }
         return forTokenWrite(replicationStrategy, natural, pending);
     }
@@ -392,14 +394,25 @@ static EndpointsForRange forNonLocalStategyRangeRead(ClusterMetadata metadata, K
 
     public static EndpointsForToken forNonLocalStrategyTokenRead(ClusterMetadata metadata, KeyspaceMetadata keyspace, Token token)
     {
-        return metadata.placements.get(keyspace.params.replication).reads.forToken(token).get();
+        return forNonLocalStrategyTokenRead(metadata.placements.get(keyspace.params.replication), token);
+    }
+
+    public static EndpointsForToken forNonLocalStrategyTokenRead(DataPlacement dataPlacement, Token token)
+    {
+        return dataPlacement.reads.forToken(token).get();
     }
 
     static EndpointsForToken forNonLocalStrategyTokenWrite(ClusterMetadata metadata, KeyspaceMetadata keyspace, Token token)
     {
-        return metadata.placements.get(keyspace.params.replication).writes.forToken(token).get();
+        return forNonLocalStrategyTokenWrite(metadata.placements.get(keyspace.params.replication), token);
     }
 
+    static EndpointsForToken forNonLocalStrategyTokenWrite(DataPlacement dataPlacement, Token token)
+    {
+        return dataPlacement.writes.forToken(token).get();
+    }
+
+
     static EndpointsForRange forLocalStrategyRange(ClusterMetadata metadata, AbstractReplicationStrategy replicationStrategy, AbstractBounds<PartitionPosition> range)
     {
         return replicationStrategy.calculateNaturalReplicas(range.right.getToken(), metadata);

src/java/org/apache/cassandra/schema/KeyspaceParams.java

@@ -117,6 +117,11 @@ public static KeyspaceParams nts(Object... args)
         return new KeyspaceParams(true, ReplicationParams.nts(args), FastPathStrategy.simple());
     }
 
+    public KeyspaceParams withSwapped(ReplicationParams params)
+    {
+        return new KeyspaceParams(durableWrites, params, fastPath);
+    }
+
     public void validate(String name, ClientState state, ClusterMetadata metadata)
     {
         replication.validate(name, state, metadata);

src/java/org/apache/cassandra/schema/ReplicationParams.java

@@ -57,11 +57,13 @@ public final class ReplicationParams
 
     public final Class<? extends AbstractReplicationStrategy> klass;
     public final ImmutableMap<String, String> options;
+    private final int hashCode;
 
     private ReplicationParams(Class<? extends AbstractReplicationStrategy> klass, Map<String, String> options)
     {
         this.klass = klass;
         this.options = ImmutableMap.copyOf(options);
+        this.hashCode = Objects.hashCode(this.klass, this.options);
     }
 
     @VisibleForTesting
@@ -234,7 +236,7 @@ public boolean equals(Object o)
     @Override
     public int hashCode()
     {
-        return Objects.hashCode(klass, options);
+        return hashCode;
     }
 
     @Override

src/java/org/apache/cassandra/tcm/ownership/DataPlacements.java

@@ -159,6 +159,17 @@ public boolean equivalentTo(DataPlacements other)
                   .allMatch(e -> e.getValue().equivalentTo(other.get(e.getKey())));
     }
 
+    public ReplicationParams deduplicateReplicationParams(ReplicationParams replicationParams)
+    {
+        if (this.get(replicationParams) == null)
+            return replicationParams;
+
+        for (ReplicationParams placementReplicationParams : keys())
+            if (placementReplicationParams.equals(replicationParams))
+                return placementReplicationParams;
+        return replicationParams;
+    }
+
     public static DataPlacements sortReplicaGroups(DataPlacements placements, Comparator<Replica> comparator)
     {
         Builder builder = DataPlacements.builder(placements.size());