perf: inline has_checksumming_support check to avoid classmethod call overhead

Replace ProtocolVersion.has_checksumming_support(protocol_version) calls
in encode_message and decode_message with inline integer comparisons
using pre-computed module-level constants. This avoids the classmethod
dispatch overhead on every encode/decode call.

Benchmark:
  classmethod call: 61.3 ns
  inline compare:   25.5 ns
  saving: 35.8 ns/call (2.4x)

Author: mykaul

benchmarks/bench_checksumming_inline.py

@@ -0,0 +1,57 @@
+# Copyright ScyllaDB, Inc.
+#
+# 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.
+
+"""
+Micro-benchmark: inline checksumming check vs classmethod call.
+
+Measures the overhead of ProtocolVersion.has_checksumming_support()
+classmethod call versus an inline integer comparison on the
+encode/decode hot path.
+
+Run:
+    python benchmarks/bench_checksumming_inline.py
+"""
+
+import sys
+import timeit
+
+from cassandra import ProtocolVersion
+from cassandra.protocol import _CHECKSUMMING_MIN_VERSION, _CHECKSUMMING_MAX_VERSION
+
+
+def bench():
+    protocol_version = ProtocolVersion.V4
+
+    def via_classmethod():
+        return ProtocolVersion.has_checksumming_support(protocol_version)
+
+    def via_inline():
+        return _CHECKSUMMING_MIN_VERSION <= protocol_version < _CHECKSUMMING_MAX_VERSION
+
+    n = 5_000_000
+    t_classmethod = timeit.timeit(via_classmethod, number=n)
+    t_inline = timeit.timeit(via_inline, number=n)
+
+    saving_ns = (t_classmethod - t_inline) / n * 1e9
+    speedup = t_classmethod / t_inline if t_inline > 0 else float('inf')
+
+    print(f"=== has_checksumming_support ({n:,} iters) ===")
+    print(f"  classmethod call: {t_classmethod / n * 1e9:.1f} ns")
+    print(f"  inline compare:   {t_inline / n * 1e9:.1f} ns")
+    print(f"  saving: {saving_ns:.1f} ns/call ({speedup:.1f}x)")
+
+
+if __name__ == "__main__":
+    print(f"Python {sys.version}")
+    bench()

cassandra/protocol.py

@@ -69,6 +69,12 @@ class InternalError(Exception):
 
 _UNSET_VALUE = object()
 
+# Inline constants for has_checksumming_support check, avoiding
+# ProtocolVersion.has_checksumming_support() classmethod call overhead
+# (~94 ns per call) on the encode/decode hot path.
+_CHECKSUMMING_MIN_VERSION = ProtocolVersion.V5
+_CHECKSUMMING_MAX_VERSION = ProtocolVersion.DSE_V1
+
 
 def register_class(cls):
     _message_types_by_opcode[cls.opcode] = cls
@@ -1100,7 +1106,7 @@ def encode_message(cls, msg, stream_id, protocol_version, compressor, allow_beta
         buff = io.BytesIO()
 
         # With checksumming, the compression is done at the segment frame encoding
-        if (compressor and not ProtocolVersion.has_checksumming_support(protocol_version)):
+        if (compressor and not (_CHECKSUMMING_MIN_VERSION <= protocol_version < _CHECKSUMMING_MAX_VERSION)):
             if msg.custom_payload:
                 write_bytesmap(buff, msg.custom_payload)
             msg.send_body(buff, protocol_version)
@@ -1149,7 +1155,7 @@ def decode_message(cls, protocol_version, protocol_features, user_type_map, stre
         :param decompressor: optional decompression function to inflate the body
         :return: a message decoded from the body and frame attributes
         """
-        if (not ProtocolVersion.has_checksumming_support(protocol_version) and
+        if (not (_CHECKSUMMING_MIN_VERSION <= protocol_version < _CHECKSUMMING_MAX_VERSION) and
                 flags & COMPRESSED_FLAG):
             if decompressor is None:
                 raise RuntimeError("No de-compressor available for compressed frame!")