Performance Tuning

-- Before: SELECT * fetches all 20+ columns SELECT * FROM orders_by_user ... -- After: Select only what you need SELECT order_id, order_date, total_amount, status FROM orders_by_user WHERE user_id = ? LIMIT 100;

// Python - prepare once, execute many prepared = session.prepare(""" SELECT order_id, order_date, total_amount, status FROM orders_by_user WHERE user_id = ? """) # Reuse prepared statement (faster!) result = session.execute(prepared, [user_id])

-- Enable row cache for hot tables ALTER TABLE orders_by_user WITH caching = { 'keys': 'ALL', 'rows_per_partition': '100' };

// Create index on application side const orderCache = new Map(); function getOrders(userId) { if (orderCache.has(userId)) { return orderCache.get(userId); } const orders = cassandra.execute(query, [userId]); orderCache.set(userId, orders); return orders; }

from cassandra.query import BatchStatement batch = BatchStatement() prepared = session.prepare(""" INSERT INTO sensor_data (sensor_id, timestamp, value) VALUES (?, ?, ?) """) # Batch 100 inserts together for reading in readings[:100]: batch.add(prepared, (reading.id, reading.time, reading.value)) session.execute(batch) # Single network call!

from cassandra.concurrent import execute_concurrent_with_args prepared = session.prepare(""" INSERT INTO sensor_data (sensor_id, timestamp, value) VALUES (?, ?, ?) """) # Execute 100 queries concurrently parameters = [(r.id, r.time, r.value) for r in readings] execute_concurrent_with_args( session, prepared, parameters, concurrency=100 )

# cassandra.yaml tuning concurrent_writes: 128 # Default: 32, increase for write-heavy memtable_flush_writers: 4 # Parallel flushes commitlog_sync: periodic # vs batch (faster) commitlog_sync_period_in_ms: 10 # Consistency level tuning consistency_level = ONE # Faster writes (vs QUORUM)

-- For same partition, use UNLOGGED BEGIN UNLOGGED BATCH INSERT INTO sensor_data (...) VALUES (...); INSERT INTO sensor_data (...) VALUES (...); INSERT INTO sensor_data (...) VALUES (...); APPLY BATCH; -- Skip distributed log = faster -- Only use if all inserts go to same partition!

# jvm.options - Before (CMS) -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled # After (G1GC - better for large heaps) -XX:+UseG1GC -XX:G1RSetUpdatingPauseTimePercent=5 -XX:MaxGCPauseMillis=500 -XX:InitiatingHeapOccupancyPercent=70

# cassandra-env.sh # Before: Too large (16GB) MAX_HEAP_SIZE="16G" # After: Optimal for G1GC (8-12GB) MAX_HEAP_SIZE="10G" HEAP_NEWSIZE="2G" # Rule: 1/4 to 1/2 of system RAM, max 12GB

# cassandra.yaml memtable_heap_space_in_mb: 2048 memtable_offheap_space_in_mb: 2048 memtable_cleanup_threshold: 0.6 # Flush more aggressively memtable_flush_writers: 4 concurrent_compactors: 4

# cassandra.yaml key_cache_size_in_mb: 100 # Was: 500 (too large) row_cache_size_in_mb: 0 # Disable if causing pressure # Let OS page cache handle caching

# cassandra.yaml # Internode compression (DC to DC) internode_compression: dc # Client-server compression client_encryption_options: enabled: true compression: lz4 # SSTable compression ALTER TABLE users WITH compression = { 'sstable_compression': 'LZ4Compressor', 'chunk_length_kb': 64 };

// Before: QUORUM (waits for all DCs) consistency_level = QUORUM; // After: LOCAL_QUORUM (local DC only) consistency_level = LOCAL_QUORUM; // Async replication to other DCs // Much faster for writes!

# cassandra.yaml # Limit streaming bandwidth stream_throughput_outbound_megabits_per_sec: 200 inter_dc_stream_throughput_outbound_megabits_per_sec: 50 # Prevents saturating network links

-- Use appropriate data types (smaller = less transfer) CREATE TABLE events ( event_id uuid, timestamp bigint, -- vs timestamp (smaller) event_type tinyint, -- vs text (much smaller!) data blob -- compressed JSON );

-- For read-heavy workloads ALTER TABLE users WITH compaction = { 'class': 'LeveledCompactionStrategy', 'sstable_size_in_mb': 160 }; -- Benefits: -- - Smaller, more frequent compactions -- - Lower read amplification (fewer SSTables) -- - More predictable performance

-- For time-series data (IoT, logs, metrics) ALTER TABLE sensor_readings WITH compaction = { 'class': 'TimeWindowCompactionStrategy', 'compaction_window_size': '24', 'compaction_window_unit': 'HOURS' }; -- Only compacts data within time windows -- Perfect for time-series with TTL

# cassandra.yaml compaction_throughput_mb_per_sec: 64 # Default: 16 concurrent_compactors: 4 # Default: 1 # Or disable throttling entirely on fast SSDs: compaction_throughput_mb_per_sec: 0 # No limit

-- Fine-tune STCS if keeping it ALTER TABLE events WITH compaction = { 'class': 'SizeTieredCompactionStrategy', 'min_threshold': 4, -- Compact sooner 'max_threshold': 32, -- More SSTables per compaction 'bucket_high': 1.5, -- Tighter buckets 'bucket_low': 0.5 };