दोन याकोझुनाची लढाई किंवा कॅसॅन्ड्रा विरुद्ध एचबेस. Sberbank संघाचा अनुभव

हा एक विनोद देखील नाही, असे दिसते की हे विशिष्ट चित्र या डेटाबेसचे सार अगदी अचूकपणे प्रतिबिंबित करते आणि शेवटी हे का स्पष्ट होईल:

DB-Engines Ranking नुसार, दोन सर्वात लोकप्रिय NoSQL स्तंभीय डेटाबेस म्हणजे Cassandra (यापुढे CS) आणि HBase (HB).

नशिबाच्या इच्छेनुसार, Sberbank मधील आमची डेटा लोडिंग मॅनेजमेंट टीम आधीच आहे खूप पूर्वी आणि HB सह जवळून कार्य करते. या वेळी, आम्ही त्याची ताकद आणि कमकुवतपणाचा चांगला अभ्यास केला आणि ते कसे शिजवायचे ते शिकलो. तथापि, सीएसच्या रूपात पर्यायी उपस्थितीने आम्हाला नेहमी शंकांनी स्वतःला त्रास देण्यास भाग पाडले: आम्ही योग्य निवड केली आहे का? शिवाय, परिणाम तुलना, DataStax द्वारे सादर केले गेले, ते म्हणाले की CS सहजपणे HB ला जवळजवळ क्रशिंग स्कोअरसह हरवते. दुसरीकडे, DataStax एक स्वारस्य असलेला पक्ष आहे आणि तुम्ही त्यासाठी त्यांचा शब्द घेऊ नये. आम्ही चाचणीच्या परिस्थितींबद्दल थोड्या प्रमाणात माहितीमुळे गोंधळलो होतो, म्हणून आम्ही बिगडेटा NoSql चा राजा कोण आहे हे स्वतः शोधण्याचा निर्णय घेतला आणि प्राप्त झालेले परिणाम अतिशय मनोरंजक असल्याचे दिसून आले.

तथापि, केलेल्या चाचण्यांच्या निकालांकडे जाण्यापूर्वी, पर्यावरण कॉन्फिगरेशनच्या महत्त्वपूर्ण पैलूंचे वर्णन करणे आवश्यक आहे. वस्तुस्थिती अशी आहे की सीएसचा वापर अशा मोडमध्ये केला जाऊ शकतो जो डेटा गमावण्याची परवानगी देतो. त्या. हे असे होते जेव्हा विशिष्ट कीच्या डेटासाठी फक्त एक सर्व्हर (नोड) जबाबदार असतो आणि जर काही कारणास्तव तो अयशस्वी झाला तर या कीचे मूल्य गमावले जाईल. बर्याच कामांसाठी हे गंभीर नाही, परंतु बँकिंग क्षेत्रासाठी हा नियमापेक्षा अपवाद आहे. आमच्या बाबतीत, विश्वसनीय स्टोरेजसाठी डेटाच्या अनेक प्रती असणे महत्त्वाचे आहे.

म्हणून, तिहेरी प्रतिकृती मोडमध्ये फक्त CS ऑपरेटिंग मोडचा विचार केला गेला, म्हणजे. केसस्पेसची निर्मिती खालील पॅरामीटर्ससह केली गेली:

CREATE KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3};

पुढे, सुसंगततेची आवश्यक पातळी सुनिश्चित करण्याचे दोन मार्ग आहेत. सामान्य नियम:
NW + NR > RF

याचा अर्थ असा की (NW) लिहिताना नोड्सच्या पुष्टीकरणांची संख्या तसेच वाचताना (NR) नोड्सच्या पुष्टीकरणांची संख्या प्रतिकृती घटकापेक्षा जास्त असणे आवश्यक आहे. आमच्या बाबतीत, RF = 3, म्हणजे खालील पर्याय योग्य आहेत:
2 + 2 > 3
3 + 1 > 3

डेटा शक्य तितक्या विश्वासार्हपणे संग्रहित करणे आमच्यासाठी मूलभूतपणे महत्त्वाचे असल्याने, 3+1 योजना निवडण्यात आली. याव्यतिरिक्त, एचबी समान तत्त्वावर कार्य करते, म्हणजे. अशी तुलना अधिक न्याय्य असेल.

हे नोंद घ्यावे की डेटास्टॅक्सने त्यांच्या अभ्यासात उलट केले, त्यांनी सीएस आणि एचबी दोन्हीसाठी आरएफ = 1 सेट केले (नंतरच्यासाठी एचडीएफएस सेटिंग्ज बदलून). ही खरोखर महत्त्वाची बाब आहे कारण या प्रकरणात CS कार्यक्षमतेवर होणारा परिणाम मोठा आहे. उदाहरणार्थ, खालील चित्र CS मध्ये डेटा लोड करण्यासाठी लागणारा वेळ दर्शविते:

येथे आपण खालील पाहतो: जितके अधिक प्रतिस्पर्धी थ्रेड डेटा लिहितात, तितका जास्त वेळ लागतो. हे साहजिक आहे, परंतु हे महत्त्वाचे आहे की RF=3 साठी कार्यक्षमतेत घट लक्षणीयरीत्या जास्त आहे. दुसऱ्या शब्दांत, जर आपण प्रत्येकी 4 टेबल्समध्ये (एकूण 5) 20 थ्रेड्स लिहितो, तर RF=3 सुमारे 2 पटीने कमी होतो (RF=150 साठी 3 सेकंद विरुद्ध RF=75 साठी 1). परंतु जर आपण प्रत्येकी 8 थ्रेडसह 5 टेबल्समध्ये डेटा लोड करून लोड वाढवला (एकूण 40), तर RF=3 चे नुकसान आधीच 2,7 पट (375 सेकंद विरुद्ध 138) आहे.

कदाचित हे CS साठी DataStax द्वारे केलेल्या यशस्वी लोड चाचणीचे अंशतः रहस्य आहे, कारण HB साठी आमच्या स्टँडवर प्रतिकृती घटक 2 ते 3 पर्यंत बदलण्याचा कोणताही परिणाम झाला नाही. त्या. डिस्क्स आमच्या कॉन्फिगरेशनसाठी HB बॉटलनेक नाहीत. तथापि, येथे इतर अनेक तोटे आहेत, कारण हे लक्षात घेतले पाहिजे की आमची HB आवृत्ती थोडीशी पॅच आणि चिमटा आहे, वातावरण पूर्णपणे भिन्न आहे, इ. हे देखील लक्षात घेण्यासारखे आहे की कदाचित मला CS योग्यरित्या कसे तयार करावे हे माहित नाही आणि त्यासह कार्य करण्याचे आणखी काही प्रभावी मार्ग आहेत आणि मला आशा आहे की आम्हाला टिप्पण्यांमध्ये सापडेल. पण प्रथम गोष्टी प्रथम.

सर्व चाचण्या 4 सर्व्हर असलेल्या हार्डवेअर क्लस्टरवर केल्या गेल्या, प्रत्येक खालील कॉन्फिगरेशनसह:

CPU: Xeon E5-2680 v4 @ 2.40GHz 64 थ्रेड्स.
डिस्क: 12 तुकडे SATA HDD
java आवृत्ती: 1.8.0_111

CS आवृत्ती: 3.11.5

cassandra.yml पॅरामीटर्सnum_tokens: 256
hinted_handoff_enabled: खरे
hinted_handoff_throttle_in_kb: 1024
कमाल_संकेत_वितरण_थ्रेड: २
hints_directory: /data10/cassandra/hints
hints_flush_period_in_ms: 10000
max_hints_file_size_in_mb: 128
batchlog_replay_throttle_in_kb: 1024
प्रमाणकर्ता: AllowAllAuthenticator
अधिकृत: AllowAllAuthorizer
भूमिका_व्यवस्थापक: CassandraRoleManager
भूमिका_वैधता_इन_एमएस: 2000
permissions_validity_in_ms: 2000
credentials_validity_in_ms: 2000
विभाजनकर्ता: org.apache.cassandra.dht.Murmur3Partitioner
data_file_directories:
- /data1/cassandra/data # प्रत्येक dataN निर्देशिका वेगळी डिस्क आहे
- /data2/cassandra/data
- /data3/cassandra/data
- /data4/cassandra/data
- /data5/cassandra/data
- /data6/cassandra/data
- /data7/cassandra/data
- /data8/cassandra/data
commitlog_directory: /data9/cassandra/commitlog
cdc_enabled: असत्य
disk_failure_policy: थांबवा
कमिट_फेल्युअर_पॉलिसी: थांबवा
तयार_स्टेटमेंट्स_cache_size_mb:
thrift_prepared_statements_cache_size_mb:
key_cache_size_in_mb:
key_cache_save_period: 14400
row_cache_size_in_mb: 0
row_cache_save_period: 0
counter_cache_size_in_mb:
counter_cache_save_period: 7200
saved_caches_directory: /data10/cassandra/saved_caches
कमिटलॉग_सिंक: नियतकालिक
commitlog_sync_period_in_ms: 10000
commitlog_segment_size_in_mb: 32
बियाणे_प्रदाता:
- class_name: org.apache.cassandra.locator.SimpleSeedProvider
पॅरामिटर्स:
— बिया: "*,*"
concurrent_reads: 256 # 64 प्रयत्न केला - फरक लक्षात आला नाही
concurrent_writes: 256 # 64 प्रयत्न केला - फरक लक्षात आला नाही
concurrent_counter_writes: 256 # प्रयत्न केला 64 - फरक लक्षात आला नाही
concurrent_materialized_view_writes: 32
memtable_heap_space_in_mb: 2048 # ने 16 GB प्रयत्न केला - ते हळू होते
memtable_allocation_type: heap_buffers
index_summary_capacity_in_mb:
index_summary_resize_interval_in_minutes: 60
trickle_fsync: असत्य
trickle_fsync_interval_in_kb: 10240
स्टोरेज_पोर्ट: 7000
ssl_storage_port: 7001
ऐका_पत्ता: *
प्रसारण_पत्ता: *
listen_on_broadcast_address: true
internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
start_native_transport: खरे
नेटिव्ह_ट्रान्सपोर्ट_पोर्ट: 9042
start_rpc: खरे
rpc_address: *
rpc_port: 9160
rpc_keepalive: खरे
rpc_server_type: सिंक
thrift_framed_transport_size_in_mb: 15
incremental_backups: असत्य
snapshot_before_compaction: असत्य
auto_snapshot: खरे
column_index_size_in_kb: 64
column_index_cache_size_in_kb: 2
समवर्ती_कॉम्पॅक्टर: ४
compaction_throughput_mb_per_sec: 1600
sstable_preemptive_open_interval_in_mb: 50
read_request_timeout_in_ms: 100000
range_request_timeout_in_ms: 200000
write_request_timeout_in_ms: 40000
counter_write_request_timeout_in_ms: 100000
cas_contention_timeout_in_ms: 20000
truncate_request_timeout_in_ms: 60000
request_timeout_in_ms: 200000
slow_query_log_timeout_in_ms: 500
cross_node_timeout: असत्य
endpoint_snitch: GossipingPropertyFileSnitch
dynamic_snitch_update_interval_in_ms: 100
dynamic_snitch_reset_interval_in_ms: 600000
dynamic_snitch_badness_threshold: 0.1
request_scheduler: org.apache.cassandra.scheduler.NoScheduler
सर्व्हर_एनक्रिप्शन_पर्याय:
internode_encryption: काहीही नाही
client_encryption_options:
सक्षम: असत्य
internode_compression: dc
inter_dc_tcp_nodelay: असत्य
tracetype_query_ttl: 86400
tracetype_repair_ttl: 604800
enable_user_defined_functions: असत्य
enable_scripted_user_defined_functions: असत्य
windows_timer_interval: 1
पारदर्शक_डेटा_एनक्रिप्शन_पर्याय:
सक्षम: असत्य
tombstone_warn_threshold: 1000
tombstone_failure_threshold: 100000
batch_size_warn_threshold_in_kb: 200
batch_size_fail_threshold_in_kb: 250
unlogged_batch_across_partitions_warn_threshold: 10
compaction_large_partition_warning_threshold_mb: 100
gc_warn_threshold_in_ms: 1000
back_pressure_enabled: असत्य
enable_materialized_views: खरे
enable_sasi_indexes: खरे

GC सेटिंग्ज:

### CMS सेटिंग्ज-XX:+UseParNewGC
-XX:+ConcMarkSweepGC वापरा
-XX:+CMSParallelRemark सक्षम
-XX:सर्व्हायव्हर रेशो=8
-XX:MaxTenuringThreshold=1
-XX:CMSIinitiating OccupancyFraction=75
-XX:+सीएमएसआयची सुरुवात केवळ ऑक्युपन्सी वापरा
-XX:CMSWaitDuration=10000
-XX:+CMSParallelInitialMark सक्षम
-XX:+CMSEdenChunksRecordAlways
-XX:+CMSCवर्ग अनलोडिंग सक्षम

jvm.options मेमरी 16Gb वाटप करण्यात आली होती (आम्ही 32 Gb देखील वापरून पाहिले, कोणताही फरक लक्षात आला नाही).

टेबल कमांडसह तयार केले गेले:

CREATE TABLE ks.t1 (id bigint PRIMARY KEY, title text) WITH compression = {'sstable_compression': 'LZ4Compressor', 'chunk_length_kb': 64};

HB आवृत्ती: 1.2.0-cdh5.14.2 (org.apache.hadoop.hbase.regionserver.HRegion वर्गात आम्ही MetricsRegion वगळले ज्यामुळे RegionServer वर क्षेत्रांची संख्या 1000 पेक्षा जास्त होती तेव्हा GC झाला)

नॉन-डिफॉल्ट HBase पॅरामीटर्सzookeeper.session.timeout: 120000
hbase.rpc.टाइमआउट: 2 मिनिटे
hbase.client.scanner.timeout.period: 2 मिनिटे
hbase.master.handler.count: 10
hbase.regionserver.lease.period, hbase.client.scanner.timeout.period: 2 मिनिटे
hbase.regionserver.handler.count: 160
hbase.regionserver.metahandler.count: 30
hbase.regionserver.logroll.period: ४ तास
hbase.regionserver.maxlogs: 200
hbase.hregion.memstore.flush.size: 1 GiB
hbase.hregion.memstore.block.multiplier: 6
hbase.hstore.compactionThreshold: 5
hbase.hstore.blockingStoreFiles: 200
hbase.hregion.majorcompaction: 1 दिवस
hbase-site.xml साठी HBase सेवा प्रगत कॉन्फिगरेशन स्निपेट (सेफ्टी व्हॉल्व्ह):
hbase.regionserver.wal.codecorg.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec
hbase.master.namespace.init.timeout3600000
hbase.regionserver.optionalcacheflushinterval18000000
hbase.regionserver.thread.compaction.large12
hbase.regionserver.wal.enablecompressiontrue
hbase.hstore.compaction.max.size1073741824
hbase.server.compactchecker.interval.multiplier200
HBase RegionServer साठी Java कॉन्फिगरेशन पर्याय:
-XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSIinitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:ReservedCodeCacheSize=256m
hbase.snapshot.master.timeoutMillis: 2 मिनिटे
hbase.snapshot.region.timeout: 2 मिनिटे
hbase.snapshot.master.timeout.millis: 2 मिनिटे
HBase REST सर्व्हर कमाल लॉग आकार: 100 MiB
HBase REST सर्व्हर कमाल लॉग फाइल बॅकअप: 5
HBase थ्रिफ्ट सर्व्हर कमाल लॉग आकार: 100 MiB
HBase थ्रिफ्ट सर्व्हर कमाल लॉग फाइल बॅकअप: 5
मास्टर कमाल लॉग आकार: 100 MiB
मास्टर कमाल लॉग फाइल बॅकअप: 5
RegionServer कमाल लॉग आकार: 100 MiB
RegionServer कमाल लॉग फाइल बॅकअप: 5
HBase सक्रिय मास्टर डिटेक्शन विंडो: 4 मिनिटे
dfs.client.hedged.read.threadpool.size: 40
dfs.client.hedged.read.threshold.millis: 10 मिलीसेकंद
hbase.rest.threads.min: 8
hbase.rest.threads.max: 150
कमाल प्रक्रिया फाइल वर्णनकर्ता: 180000
hbase.thrift.minWorkerThreads: 200
hbase.master.executor.openregion.threads: 30
hbase.master.executor.closeregion.threads: 30
hbase.master.executor.serverops.threads: 60
hbase.regionserver.thread.compaction.small: 6
hbase.ipc.server.read.threadpool.size: 20
रीजन मूव्हर थ्रेड्स: 6
क्लायंट Java हीप आकार बाइट्समध्ये: 1 GiB
HBase REST सर्व्हर डीफॉल्ट गट: 3 GiB
HBase थ्रिफ्ट सर्व्हर डीफॉल्ट गट: 3 GiB
बाइट्समध्ये एचबेस मास्टरचा Java हीप आकार: 16 GiB
HBase RegionServer चा Java हीप आकार बाइट्समध्ये: 32 GiB

+झूकीपर
maxClientCnxns: 601
maxSessionTimeout: 120000
टेबल तयार करणे:
hbase org.apache.hadoop.hbase.util.RegionSplitter ns:t1 UniformSplit -c 64 -f cf
alter 'ns:t1', {NAME => 'cf', DATA_BLOCK_ENCODING => 'FAST_DIFF', COMPRESSION => 'GZ'}

येथे एक महत्त्वाचा मुद्दा आहे - डेटास्टॅक्सचे वर्णन HB टेबल तयार करण्यासाठी किती क्षेत्रे वापरण्यात आली हे सांगत नाही, जरी हे मोठ्या खंडांसाठी महत्त्वाचे आहे. म्हणून, चाचण्यांसाठी, प्रमाण = 64 निवडले गेले, जे 640 GB पर्यंत संचयित करण्यास अनुमती देते, म्हणजे. मध्यम आकाराचे टेबल.

चाचणीच्या वेळी, HBase कडे 22 हजार तक्ते आणि 67 हजार प्रदेश होते (वर उल्लेख केलेल्या पॅचसाठी नसल्यास आवृत्ती 1.2.0 साठी हे घातक ठरले असते).

आता कोडसाठी. विशिष्ट डेटाबेससाठी कोणती कॉन्फिगरेशन अधिक फायदेशीर आहे हे स्पष्ट नसल्यामुळे, चाचण्या विविध संयोजनांमध्ये केल्या गेल्या. त्या. काही चाचण्यांमध्ये, 4 टेबल्स एकाच वेळी लोड केल्या गेल्या (सर्व 4 नोड कनेक्शनसाठी वापरले गेले). इतर चाचण्यांमध्ये आम्ही 8 वेगवेगळ्या टेबलांसह काम केले. काही प्रकरणांमध्ये, बॅचचा आकार 100 होता, इतरांमध्ये 200 (बॅच पॅरामीटर - खाली कोड पहा). मूल्यासाठी डेटा आकार 10 बाइट्स किंवा 100 बाइट्स (डेटाआकार) आहे. एकूण, प्रत्येक वेळी प्रत्येक टेबलमध्ये 5 दशलक्ष रेकॉर्ड लिहिले आणि वाचले गेले. त्याच वेळी, प्रत्येक टेबलवर 5 थ्रेड्स लिहिले/वाचले गेले (थ्रेड क्रमांक - thNum), ज्यापैकी प्रत्येकाने स्वतःची की वापरली (गणना = 1 दशलक्ष):

if (opType.equals("insert")) {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        StringBuilder sb = new StringBuilder("BEGIN BATCH ");
        for (int i = 0; i < batch; i++) {
            String value = RandomStringUtils.random(dataSize, true, true);
            sb.append("INSERT INTO ")
                    .append(tableName)
                    .append("(id, title) ")
                    .append("VALUES (")
                    .append(key)
                    .append(", '")
                    .append(value)
                    .append("');");
            key++;
        }
        sb.append("APPLY BATCH;");
        final String query = sb.toString();
        session.execute(query);
    }
} else {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        StringBuilder sb = new StringBuilder("SELECT * FROM ").append(tableName).append(" WHERE id IN (");
        for (int i = 0; i < batch; i++) {
            sb = sb.append(key);
            if (i+1 < batch)
                sb.append(",");
            key++;
        }
        sb = sb.append(");");
        final String query = sb.toString();
        ResultSet rs = session.execute(query);
    }
}

त्यानुसार, HB साठी समान कार्यक्षमता प्रदान केली गेली:

Configuration conf = getConf();
HTable table = new HTable(conf, keyspace + ":" + tableName);
table.setAutoFlush(false, false);
List<Get> lGet = new ArrayList<>();
List<Put> lPut = new ArrayList<>();
byte[] cf = Bytes.toBytes("cf");
byte[] qf = Bytes.toBytes("value");
if (opType.equals("insert")) {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        lPut.clear();
        for (int i = 0; i < batch; i++) {
            Put p = new Put(makeHbaseRowKey(key));
            String value = RandomStringUtils.random(dataSize, true, true);
            p.addColumn(cf, qf, value.getBytes());
            lPut.add(p);
            key++;
        }
        table.put(lPut);
        table.flushCommits();
    }
} else {
    for (Long key = count * thNum; key < count * (thNum + 1); key += 0) {
        lGet.clear();
        for (int i = 0; i < batch; i++) {
            Get g = new Get(makeHbaseRowKey(key));
            lGet.add(g);
            key++;
        }
        Result[] rs = table.get(lGet);
    }
}

एचबीमध्ये क्लायंटने डेटाच्या समान वितरणाची काळजी घेणे आवश्यक आहे, की सॉल्टिंग फंक्शन असे दिसते:

public static byte[] makeHbaseRowKey(long key) {
    byte[] nonSaltedRowKey = Bytes.toBytes(key);
    CRC32 crc32 = new CRC32();
    crc32.update(nonSaltedRowKey);
    long crc32Value = crc32.getValue();
    byte[] salt = Arrays.copyOfRange(Bytes.toBytes(crc32Value), 5, 7);
    return ArrayUtils.addAll(salt, nonSaltedRowKey);
}

आता सर्वात मनोरंजक भाग - परिणाम:

आलेख स्वरूपात समान गोष्ट:

HB चा फायदा इतका आश्‍चर्यकारक आहे की CS सेटअपमध्ये काही प्रकारची अडचण असल्याचा संशय आहे. तथापि, गुगलिंग आणि सर्वात स्पष्ट पॅरामीटर्स (जसे की समवर्ती_लेखन किंवा मेमटेबल_हीप_स्पेस_इन_एमबी) शोधल्याने गोष्टींना गती मिळाली नाही. त्याच वेळी, लॉग स्वच्छ आहेत आणि कशाचीही शपथ घेत नाहीत.

डेटा सर्व नोड्सवर समान रीतीने वितरीत केला गेला, सर्व नोड्समधील आकडेवारी अंदाजे समान होती.

एका नोड्सवरून सारणीची आकडेवारी अशी दिसतेकीस्पेस: ks
वाचा संख्या: 9383707
लेटन्सी वाचा: 0.04287025042448576 ms
संख्या लिहा: 15462012
विलंब लिहा: 0.1350068438699957 ms
प्रलंबित फ्लश: 0
तक्ता: t1
SSTable संख्या: 16
वापरलेली जागा (लाइव्ह): 148.59 MiB
वापरलेली जागा (एकूण): 148.59 MiB
स्नॅपशॉट्सद्वारे वापरलेली जागा (एकूण): 0 बाइट्स
ऑफ हीप मेमरी वापरली (एकूण): 5.17 MiB
SSTable कॉम्प्रेशन रेशो: 0.5720989576459437
विभाजनांची संख्या (अंदाज): 3970323
मेमटेबल सेल संख्या: 0
मेमटेबल डेटा आकार: 0 बाइट्स
मेमटेबल ऑफ हीप मेमरी वापरली: 0 बाइट्स
मेमटेबल स्विच संख्या: 5
स्थानिक वाचन संख्या: 2346045
स्थानिक रीड लेटन्सी: NaN ms
स्थानिक लेखन संख्या: 3865503
स्थानिक लेखन विलंब: NaN ms
प्रलंबित फ्लश: 0
दुरुस्तीची टक्केवारी: 0.0
ब्लूम फिल्टर खोटे सकारात्मक: 25
ब्लूम फिल्टर चुकीचे प्रमाण: 0.00000
ब्लूम फिल्टर जागा वापरली: 4.57 MiB
ब्लूम फिल्टर ऑफ हीप मेमरी वापरली: 4.57 MiB
इंडेक्स सारांश ऑफ हीप मेमरी वापरली: 590.02 KiB
कॉम्प्रेशन मेटाडेटा ऑफ हीप मेमरी वापरली: 19.45 KiB
कॉम्पॅक्ट केलेले विभाजन किमान बाइट्स: 36
कॉम्पॅक्ट केलेले विभाजन कमाल बाइट्स: 42
कॉम्पॅक्ट केलेले विभाजन मीन बाइट्स: 42
प्रति स्लाइस सरासरी थेट पेशी (अंतिम पाच मिनिटे): NaN
प्रति स्लाइस कमाल जिवंत पेशी (शेवटची पाच मिनिटे): 0
प्रति स्लाइस सरासरी समाधी दगड (शेवटची पाच मिनिटे): NaN
प्रति स्लाइस (शेवटची पाच मिनिटे) जास्तीत जास्त थडगे: 0
ड्रॉप केलेले उत्परिवर्तन: 0 बाइट्स

बॅचचा आकार कमी करण्याच्या प्रयत्नाचा (अगदी वैयक्तिकरित्या पाठवणे) काही परिणाम झाला नाही, तो फक्त खराब झाला. हे शक्य आहे की CS साठी हे खरोखरच कमाल कार्यप्रदर्शन आहे, कारण CS साठी प्राप्त झालेले परिणाम डेटास्टॅक्ससाठी मिळालेल्या परिणामांसारखेच आहेत - प्रति सेकंद सुमारे शेकडो हजार ऑपरेशन्स. या व्यतिरिक्त, जर आपण संसाधनाचा वापर पाहिला, तर आपल्याला दिसेल की CS अधिक CPU आणि डिस्क वापरते:

आकृती दोन्ही डेटाबेससाठी लागोपाठ सर्व चाचण्या चालवताना होणारा उपयोग दर्शवते.

HB च्या शक्तिशाली वाचन फायद्याबद्दल. येथे तुम्ही पाहू शकता की दोन्ही डेटाबेससाठी, वाचनादरम्यान डिस्कचा वापर अत्यंत कमी आहे (वाचन चाचण्या प्रत्येक डेटाबेससाठी चाचणी चक्राचा अंतिम भाग आहेत, उदाहरणार्थ CS साठी हे 15:20 ते 15:40 पर्यंत आहे). एचबीच्या बाबतीत, कारण स्पष्ट आहे - बहुतेक डेटा मेमरीमध्ये, मेमस्टोअरमध्ये हँग होतो आणि काही ब्लॉककॅशेमध्ये कॅश केला जातो. CS साठी, ते कसे कार्य करते हे अगदी स्पष्ट नाही, परंतु डिस्क रीसायकलिंग देखील दृश्यमान नाही, परंतु फक्त बाबतीत, कॅशे सक्षम करण्याचा प्रयत्न केला गेला row_cache_size_in_mb = 2048 आणि सेट कॅशिंग = {'keys': 'ALL', 'rows_per_partition': '2000000'}, पण त्यामुळे ते आणखीनच बिघडले.

HB मधील प्रदेशांच्या संख्येबद्दल पुन्हा एकदा एक महत्त्वाचा मुद्दा नमूद करणे योग्य आहे. आमच्या बाबतीत, मूल्य 64 म्हणून निर्दिष्ट केले आहे. जर तुम्ही ते कमी केले आणि ते समान केले, उदाहरणार्थ, 4, तर वाचताना, वेग 2 पट कमी होईल. याचे कारण असे आहे की मेमस्टोअर जलद भरेल आणि फायली अधिक वेळा फ्लश केल्या जातील आणि वाचताना, अधिक फायलींवर प्रक्रिया करावी लागेल, जे एचबीसाठी एक जटिल ऑपरेशन आहे. वास्तविक परिस्थितीत, प्रीस्प्लिटिंग आणि कॉम्पॅक्टिफिकेशन धोरणाद्वारे विचार करून यावर उपचार केले जाऊ शकतात; विशेषतः, आम्ही एक स्वयं-लिखित उपयुक्तता वापरतो जी कचरा गोळा करते आणि पार्श्वभूमीमध्ये सतत HFiles संकुचित करते. हे शक्य आहे की डेटास्टॅक्स चाचण्यांसाठी त्यांनी प्रति टेबल फक्त 1 क्षेत्र वाटप केले (जे बरोबर नाही) आणि यामुळे त्यांच्या वाचन चाचण्यांमध्ये HB इतका निकृष्ट का आहे हे काही प्रमाणात स्पष्ट होईल.

यावरून पुढील प्राथमिक निष्कर्ष काढण्यात आले आहेत. चाचणी दरम्यान कोणतीही मोठी चूक झाली नाही असे गृहीत धरले, तर कॅसॅन्ड्रा मातीच्या पायांसह कोलोसससारखे दिसते. अधिक तंतोतंत, लेखाच्या सुरुवातीला दिलेल्या चित्राप्रमाणे ती एका पायावर समतोल राखते, ती तुलनेने चांगले परिणाम दर्शवते, परंतु त्याच परिस्थितीत झालेल्या लढतीत ती पूर्णपणे हरते. त्याच वेळी, आमच्या हार्डवेअरवर कमी CPU वापर लक्षात घेऊन, आम्ही प्रत्येक होस्टवर दोन RegionServer HB लावायला शिकलो आणि त्यामुळे कामगिरी दुप्पट झाली. त्या. संसाधनांचा वापर लक्षात घेता, CS साठी परिस्थिती आणखीनच शोचनीय आहे.

अर्थात, या चाचण्या बर्‍याच कृत्रिम आहेत आणि येथे वापरल्या गेलेल्या डेटाचे प्रमाण तुलनेने माफक आहे. हे शक्य आहे की जर आम्ही टेराबाइट्सवर स्विच केले तर परिस्थिती वेगळी असेल, परंतु HB साठी आम्ही टेराबाइट लोड करू शकतो, CS साठी हे समस्याप्रधान असल्याचे दिसून आले. डिफॉल्टच्या तुलनेत प्रतिसादाची वाट पाहण्याचे पॅरामीटर्स आधीच अनेक पटीने वाढले असले तरीही या खंडांसह अनेकदा ऑपरेशन टाइमआउट एक्सेप्शन दिले.

मला आशा आहे की संयुक्त प्रयत्नांद्वारे आम्ही CS च्या अडथळ्यांना शोधून काढू आणि जर आम्ही त्यास गती देऊ शकलो तर पोस्टच्या शेवटी मी निश्चितपणे अंतिम निकालांबद्दल माहिती जोडेन.

UPD: कॉम्रेडच्या सल्ल्याबद्दल धन्यवाद, मी वाचनाचा वेग वाढवू शकलो. होते:
159 ऑप्स (644 टेबल, 4 प्रवाह, बॅच 5).
जोडले:
.withLoadBalancingPolicy(नवीन TokenAwarePolicy(DCAwareRoundRobinPolicy.builder().build()))
आणि मी थ्रेड्सच्या संख्येसह खेळलो. परिणाम खालीलप्रमाणे आहे:
4 टेबल्स, 100 थ्रेड्स, बॅच = 1 (तुकडा तुकडा): 301 ऑप्स
4 टेबल, 100 धागे, बॅच = 10: 447 ऑप्स
4 टेबल, 100 धागे, बॅच = 100: 625 ऑप्स

नंतर मी इतर ट्यूनिंग टिप्स लागू करेन, पूर्ण चाचणी चक्र चालवीन आणि पोस्टच्या शेवटी परिणाम जोडेन.

स्त्रोत: www.habr.com