Dëst ass net emol e Witz, et schéngt, datt dëst speziell Bild am meeschte genee d'Essenz vun dësen Datenbanken reflektéiert, an um Enn wäert et kloer sinn firwat:
Geméiss dem DB-Engines Ranking sinn déi zwee beléifste NoSQL kolonner Datenbanken Cassandra (nach CS) an HBase (HB).
Duerch de Schicksalwëllen huet eis Dateload Management Team bei Sberbank schonn a schafft enk mam HB zesummen. Wärend dëser Zäit hu mir seng Stäerkten a Schwächten zimlech gutt studéiert a geléiert wéi een et kachen. Wéi och ëmmer, d'Präsenz vun enger Alternativ a Form vun CS huet eis ëmmer gezwongen eis selwer e bëssen mat Zweifel ze pine: hu mir de richtege Choix gemaach? Ausserdeem, d'Resultater , duerchgefouert vun DataStax, si soten datt CS liicht HB mat bal engem zerstéierende Score schloe. Op der anerer Säit ass DataStax eng interesséiert Partei, an Dir sollt hiert Wuert net huelen. Mir waren och duercherneen duerch déi zimlech kleng Quantitéit un Informatioun iwwer d'Testbedéngungen, also hu mir beschloss eleng erauszefannen, wien de Kinnek vu BigData NoSql ass, an d'Resultater, déi kritt goufen, ware ganz interessant.
Wéi och ëmmer, ier Dir op d'Resultater vun den duerchgefouerten Tester weidergeet, ass et néideg déi bedeitend Aspekter vun den Ëmfeldkonfiguratiounen ze beschreiwen. D'Tatsaach ass datt CS an engem Modus benotzt ka ginn, deen Datenverloscht erlaabt. Déi. Dëst ass wann nëmmen ee Server (Node) fir d'Donnéeën vun engem bestëmmte Schlëssel verantwortlech ass, a wann et aus irgendege Grënn klappt, da gëtt de Wäert vun dësem Schlëssel verluer. Fir vill Aufgaben ass dat net kritesch, mä fir de Bankesecteur ass dat éischter d'Ausnam wéi d'Regel. An eisem Fall ass et wichteg e puer Kopien vun Donnéeën fir zouverlässeg Stockage ze hunn.
Dofir gouf nëmmen de CS Betribsmodus am Triple Replikatiounsmodus berücksichtegt, d.h. D'Schafe vum Casespace gouf mat de folgende Parameteren duerchgefouert:
CREATE KEYSPACE ks WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3};
Als nächst ginn et zwee Weeër fir den erfuerderleche Konsistenzniveau ze garantéieren. Allgemeng Regel:
NW + NR > RF
Wat heescht datt d'Zuel vun de Confirmatioune vu Wirbelen beim Schreiwen (NW) plus d'Zuel vun de Bestätegunge vun de Wirbelen beim Liesen (NR) muss méi grouss sinn wéi de Replikatiounsfaktor. An eisem Fall ass RF = 3, dat heescht datt déi folgend Optiounen gëeegent sinn:
2 + 2 > 3
3 + 1 > 3
Well et eis grondleeënd wichteg ass, d'Donnéeën esou zouverlässeg wéi méiglech ze späicheren, gouf den 3+1 Schema gewielt. Ausserdeem funktionéiert den HB no engem ähnleche Prinzip, d.h. esou e Verglach wäert méi fair sinn.
Et sollt bemierkt datt DataStax de Géigendeel an hirer Studie gemaach huet, si setzen RF = 1 fir béid CS an HB (fir déi lescht andeems d'HDFS Astellunge geännert ginn). Dëst ass e wierklech wichtegen Aspekt well den Impakt op d'CS Leeschtung an dësem Fall enorm ass. Zum Beispill, d'Bild hei ënnen weist d'Erhéijung vun der Zäit néideg fir Daten an CS ze lueden:
Hei gesi mir déi folgend: wat méi konkurréiere thread Daten schreiwen, wat méi laang et dauert. Dëst ass natierlech, awer et ass wichteg datt d'Leeschtungsdegradatioun fir RF = 3 wesentlech méi héich ass. An anere Wierder, wa mir 4 Threads an all 5 Dëscher schreiwen (20 am Ganzen), da verléiert RF=3 ongeféier 2 Mol (150 Sekonnen fir RF=3 versus 75 fir RF=1). Awer wa mir d'Belaaschtung erhéijen andeems d'Daten an 8 Dëscher mat all 5 Threads lued (40 am Ganzen), dann ass de Verloscht vu RF=3 scho 2,7 Mol (375 Sekonnen versus 138).
Vläicht ass dëst deelweis d'Geheimnis vun der erfollegräicher Lasttestung, déi vun DataStax fir CS gemaach gëtt, well fir HB op eisem Stand d'Ännerung vum Replikatiounsfaktor vun 2 op 3 keen Effekt huet. Déi. Disks sinn net den HB Flaschenhals fir eis Konfiguratioun. Wéi och ëmmer, et gi vill aner Fallen hei, well et sollt bemierkt datt eis Versioun vum HB liicht gefléckt an ugepasst gouf, d'Ëmfeld sinn komplett anescht, etc. Et ass och ze bemierken datt ech vläicht just net weess wéi ech CS richteg virbereeden an et ginn e puer méi effektiv Weeër fir domat ze schaffen, an ech hoffen, datt mir an de Kommentaren erausfannen. Awer éischt Saachen éischt.
All Tester goufen op engem Hardware-Cluster ausgefouert, besteet aus 4 Serveren, jidderee mat der folgender Konfiguratioun:
CPU: Xeon E5-2680 v4 @ 2.40GHz 64 thread.
Disken: 12 Stécker SATA HDD
Java Versioun: 1.8.0_111
CS Versioun: 3.11.5
cassandra.yml Parameterennum_tokens: 256
hinted_handoff_enabled: wouer
hinted_handoff_throttle_in_kb: 1024
max_hints_delivery_threads: 2
hints_directory: /data10/cassandra/hints
hints_flush_period_in_ms: 10000
max_hints_file_size_in_mb: 128
batchlog_replay_throttle_in_kb: 1024
authenticator: AllowAllAuthenticator
autoriséierter: AllowAllAuthorizer
role_manager: CassandraRoleManager
roles_validity_in_ms: 2000
permissions_validity_in_ms: 2000
credentials_validity_in_ms: 2000
partitioner: org.apache.cassandra.dht.Murmur3Partitioner
daten_Datei_Verzeichnungen:
- /data1/cassandra/data # all dataN Verzeichnis ass eng separat Scheif
- /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: falsch
disk_failure_policy: stoppen
commit_failure_policy: stoppen
prepare_statements_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: periodesch
commitlog_sync_period_in_ms: 10000
commitlog_segment_size_in_mb: 32
seed_provider:
- class_name: org.apache.cassandra.locator.SimpleSeedProvider
Parameter:
- Somen: "*,*"
concurrent_reads: 256 # probéiert 64 - keen Ënnerscheed gemierkt
concurrent_writes: 256 # probéiert 64 - keen Ënnerscheed gemierkt
concurrent_counter_writes: 256 # probéiert 64 - keen Ënnerscheed gemierkt
concurrent_materialized_view_writes: 32
memtable_heap_space_in_mb: 2048 # probéiert 16 GB - et war méi lues
memtable_allocation_type: heap_buffers
index_summary_capacity_in_mb:
index_summary_size_interval_in_minutes: 60
trickle_fsync: falsch
trickle_fsync_interval_in_kb: 10240
Stockage_port: 7000
ssl_storage_port: 7001
lauschteren_Adress: *
Broadcast_Adress: *
listen_on_broadcast_address: richteg
internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
start_native_transport: wouer
native_transport_port: 9042
start_rpc: wouer
rpc_address: *
rpc_port: 9160
rpc_keepalive: wouer
rpc_server_type: sync
thrift_framed_transport_size_in_mb: 15
incremental_backups: falsch
snapshot_before_compaction: falsch
auto_snapshot: wouer
column_index_size_in_kb: 64
column_index_cache_size_in_kb: 2
concurrent_compactors: 4
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: falsch
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
server_encryption_options:
internode_encryption: keng
client_encryption_optiounen:
ageschalt: falsch
internode_compression: dc
inter_dc_tcp_nodelay: falsch
tracetype_query_ttl: 86400
tracetype_repair_ttl: 604800
enable_user_defined_functions: falsch
enable_scripted_user_defined_functions: falsch
windows_timer_interval: 1
transparent_data_encryption_options:
ageschalt: falsch
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: falsch
enable_materialized_views: richteg
enable_sasi_indexes: richteg
GC Astellungen:
### CMS Astellungen-XX:+UseParNewGC
-XX:+UseConcMarkSweepGC
-XX:+CMSParallelRemarkEnabled
-XX:SurvivorRatio=8
-XX:MaxTenuringThreshold=1
-XX:CMSInitiatingOccupancyFraction=75
-XX:+UseCMSIinitiatingOccupancyOnly
-XX:CMSWaitDuration=10000
-XX:+CMSParallelInitialMarkEnabled
-XX:+CMSEdenChunksRecordAlways
-XX:+CMSClassUnloadingEnabled
D'jvm.options Erënnerung war 16Gb zougewisen (mir probéiert och 32 Gb, keen Ënnerscheed war gemierkt).
D'Dëscher goufen mam Kommando erstallt:
CREATE TABLE ks.t1 (id bigint PRIMARY KEY, title text) WITH compression = {'sstable_compression': 'LZ4Compressor', 'chunk_length_kb': 64};HB Versioun: 1.2.0-cdh5.14.2 (an der Klass org.apache.hadoop.hbase.regionserver.HRegion hu mir MetricsRegion ausgeschloss, wat zu GC gefouert huet wann d'Zuel vun de Regiounen méi wéi 1000 op RegionServer war)
Net-Standard HBase Parameterenzookeeper.session.timeout: 120000
hbase.rpc.timeout: 2 Minute(n)
hbase.client.scanner.timeout.period: 2 Minute(n)
hbase.master.handler.count: 10
hbase.regionserver.lease.period, hbase.client.scanner.timeout.period: 2 minute(s)
hbase.regionserver.handler.count: 160
hbase.regionserver.metahandler.count: 30
hbase.regionserver.logroll.period: 4 Stonn(en)
hbase.regionserver.maxlogs: 200
hbase.hregion.memstore.flush.Gréisst: 1 GiB
hbase.hregion.memstore.block.multiplikator: 6
hbase.hstore.compactionThreshold: 5
hbase.hstore.blockingStoreFiles: 200
hbase.hregion.majorcompaction: 1 Dag(en)
HBase Service Advanced Configuration Snippet (Sécherheetsventil) fir hbase-site.xml:
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
Java Konfiguratiounsoptioune fir HBase RegionServer:
-XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70 -XX:+CMSParallelRemarkEnabled -XX:ReservedCodeCacheSize=256m
hbase.snapshot.master.timeoutMillis: 2 Minute(n)
hbase.snapshot.region.timeout: 2 Minute(n)
hbase.snapshot.master.timeout.millis: 2 Minute(n)
HBase REST Server Max Log Gréisst: 100 MiB
HBase REST Server Maximal Log Datei Backups: 5
HBase Thrift Server Max Log Gréisst: 100 MiB
HBase Thrift Server Maximal Log Datei Backups: 5
Master Max Log Gréisst: 100 MiB
Master Maximum Log Datei Backups: 5
RegionServer Max Log Gréisst: 100 MiB
RegionServer Maximal Log Datei Backups: 5
HBase Active Master Detection Window: 4 Minute(s)
dfs.client.hedged.read.threadpool.Gréisst: 40
dfs.client.hedged.read.threshold.millis: 10 millisecond(s)
hbase.rest.threads.min: 8
hbase.rest.threads.max: 150
Maximal Prozess Datei Descriptoren: 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
Regioun Mover Threads: 6
Client Java Heap Gréisst a Bytes: 1 GiB
HBase REST Server Default Group: 3 GiB
HBase Thrift Server Default Group: 3 GiB
Java Heap Gréisst vum HBase Master an Bytes: 16 GiB
Java Heap Gréisst vum HBase RegionServer an Bytes: 32 GiB
+ ZooKeeper
maxClientCnxns: 601
maxSessionTimeout: 120000
Dëscher erstellen:
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'}
Et gëtt e wichtege Punkt hei - d'DataStax Beschreiwung seet net wéi vill Regioune benotzt gi fir d'HB Dëscher ze kreéieren, obwuel dëst kritesch ass fir grouss Bänn. Dofir gouf fir d'Tester Quantitéit = 64 gewielt, wat et erlaabt bis zu 640 GB ze späicheren, d.h. mëttelgrouss Dësch.
Zu der Zäit vum Test hat HBase 22 Tausend Dëscher a 67 Tausend Regiounen (dëst wier fatal fir Versioun 1.2.0 wann net fir de Patch uewen ernimmt).
Elo fir de Code. Well et net kloer war wéi eng Konfiguratiounen méi avantagéis fir eng bestëmmte Datebank waren, goufen Tester a verschiddene Kombinatioune gemaach. Déi. an e puer Tester goufen 4 Dëscher gläichzäiteg gelueden (all 4 Wirbelen goufen fir Verbindung benotzt). An aneren Tester hu mir mat 8 verschiddenen Dëscher geschafft. A verschiddene Fäll war d'Batchgréisst 100, an anerer 200 (Batchparameter - kuckt de Code hei ënnen). D'Dategréisst fir Wäert ass 10 Bytes oder 100 Bytes (DataSize). Am Ganzen goufen 5 Millioune Rekorder all Kéier an all Dësch geschriwwen a gelies. Zur selwechter Zäit goufe 5 Threads op all Dësch geschriwwe / gelies (Thread Number - thNum), déi all seng eege Gamme vu Schlësselen benotzt hunn (Zuel = 1 Millioun):
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);
}
}
Deementspriechend gouf ähnlech Funktionalitéit fir HB geliwwert:
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);
}
}
Well am HB de Client sech ëm déi eenheetlech Verdeelung vun den Donnéeën këmmere muss, huet d'Schlësselsalzfunktioun esou ausgesinn:
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);
}
Elo déi interessantst Deel - d'Resultater:
Datselwecht a Grafikform:
De Virdeel vum HB ass sou iwwerraschend datt et e Verdacht ass datt et eng Zort Flaschenhals am CS-Setup ass. Wéi och ëmmer, Googelen a sichen no den offensichtlechste Parameteren (wéi concurrent_writes oder memtable_heap_space_in_mb) huet d'Saache net beschleunegt. Zur selwechter Zäit sinn d'Protokoller propper a schwieren näischt.
D'Date goufen gläichméisseg iwwer d'Knäpper verdeelt, d'Statistike vun allen Wirbelen waren ongeféier d'selwecht.
Dëst ass wéi d'Tabelstatistike vun engem vun den Noden ausgesinnSchlësselraum: ks
Lieszuel: 9383707
Liest Latenz: 0.04287025042448576 ms
Schreifzuel: 15462012
Schreift Latenz: 0.1350068438699957 ms
Erwaardung Spullungen: 0
Dësch: t1
SSTable Zuel: 16
Plaz benotzt (liewen): 148.59 MiB
Plaz benotzt (total): 148.59 MiB
Raum benotzt vun Schnappschëss (total): 0 Bytes
Off Heap Erënnerung benotzt (total): 5.17 MiB
SSTable Kompressiounsverhältnis: 0.5720989576459437
Zuel vun de Partitionen (Schätzung): 3970323
Memtable Zellzuel: 0
Memtable Daten Gréisst: 0 Bytes
Memtable Off Heap Memory benotzt: 0 Bytes
Unzuel vun Erënnerungsschalter: 5
Lokal Lieszuel: 2346045
Lokal Lieslatenz: NaN ms
Lokal Schreifzuel: 3865503
Lokal Schreiflatenz: NaN ms
Erwaardung Spullungen: 0
Prozent gefléckt: 0.0
Bloom Filter falsch Positiver: 25
Bloom Filter falsch Verhältnis: 0.00000
Bléi Filter Plaz benotzt: 4.57 MiB
Bléi Filter aus Koup Erënnerung benotzt: 4.57 MiB
Index Resumé vun Koup Erënnerung benotzt: 590.02 KiB
Kompressioun Metadaten aus Koup Erënnerung benotzt: 19.45 KiB
Kompakt Partition Minimum Bytes: 36
Kompakt Partition maximal Bytes: 42
Kompakt Partition bedeit Bytes: 42
Duerchschnëtt liewen Zellen pro Slice (lescht fënnef Minutten): NaN
Maximal liewen Zellen pro Slice (lescht fënnef Minutten): 0
Duerchschnëtt Grafsteen pro Slice (lescht fënnef Minutten): NaN
Maximal Grafsteen pro Slice (lescht fënnef Minutten): 0
Dropgesat Mutatiounen: 0 Bytes
E Versuch d'Gréisst vun der Partie ze reduzéieren (souguer individuell ze schécken) huet keen Effekt, et gouf nëmme verschlechtert. Et ass méiglech datt dëst wierklech déi maximal Leeschtung fir CS ass, well d'Resultater, déi fir CS kritt goufen, ähnlech sinn wéi déi fir DataStax - ongeféier Honnerte vun Dausende vun Operatiounen pro Sekonn. Ausserdeem, wa mir d'Ressourcenotzung kucken, wäerte mir gesinn datt CS vill méi CPU an Disken benotzt:
D'Figur weist d'Notzung während der Laf vun all Tester an enger Zeil fir béid Datenbanken.
Betreffend dem HB säi mächtege Liesvirdeel. Hei kënnt Dir gesinn datt fir béid Datenbanken d'Disknotzung beim Liesen extrem niddereg ass (Liestester sinn de leschten Deel vum Testzyklus fir all Datebank, zum Beispill fir CS ass dëst vu 15:20 bis 15:40). Am Fall vun HB ass de Grond kloer - déi meescht vun den Daten hänken an der Erënnerung, am Memstore, an e puer sinn am Blockcache cache. Wat CS ugeet, ass et net ganz kloer wéi et funktionnéiert, awer d'Diskrecycling ass och net sichtbar, awer just am Fall wou e Versuch gemaach gouf fir den Cache row_cache_size_in_mb = 2048 z'aktivéieren an Caching = {'keys': 'ALL' ze setzen, 'rows_per_partition': ' 2000000'}, awer dat huet et nach e bësse verschlechtert.
Et ass och derwäert nach eng Kéier e wichtege Punkt iwwer d'Zuel vun de Regiounen am HB ze ernimmen. An eisem Fall gouf de Wäert als 64 uginn. Wann Dir et reduzéiert an et gläich wéi zum Beispill 4 mécht, dann beim Liesen fällt d'Geschwindegkeet ëm 2 Mol. De Grond ass datt de memstore méi séier opfëllt an d'Dateien méi dacks gespullt ginn a beim Liese musse méi Dateien veraarbecht ginn, wat eng zimlech komplizéiert Operatioun fir HB ass. An reelle Bedéngungen kann dëst behandelt ginn andeems Dir eng Presplitter- a Verdichtungsstrategie denkt; besonnesch benotze mir e selbstgeschriwwenen Utility deen Dreck sammelt an HFiles stänneg am Hannergrond kompriméiert. Et ass ganz méiglech datt se fir DataStax Tester nëmmen 1 Regioun pro Dësch verdeelt hunn (wat net richteg ass) an dëst géif e bësse klären firwat den HB sou schlëmm war an hire Liestester.
Déi folgend virleefeg Conclusiounen ginn aus dësem gezunn. Unzehuelen datt keng gréisser Feeler beim Test gemaach goufen, da gesäit d'Cassandra aus wéi e Koloss mat Féiss aus Lehm. Méi präzis, wärend se op engem Been balancéiert, wéi am Bild am Ufank vum Artikel, weist se relativ gutt Resultater, awer an engem Kampf ënner de selwechte Konditioune verléiert se direkt. Zur selwechter Zäit, mat der gerénger CPU Notzung op eiser Hardware berücksichtegt, hu mir geléiert zwee RegionServer HBs pro Host ze planzen an doduerch d'Performance verduebelt. Déi. Wann Dir d'Benotzung vu Ressourcen berücksichtegt, ass d'Situatioun fir CS nach méi bedauerlech.
Natierlech sinn dës Tester zimmlech synthetesch an d'Quantitéit un Daten déi hei benotzt goufen ass relativ bescheiden. Et ass méiglech datt wa mir op Terabytes wiesselen, d'Situatioun anescht wier, awer wa mir fir HB Terabytes luede kënnen, fir CS huet dëst als problematesch erausgestallt. Et huet dacks eng OperationTimedOutException och mat dëse Bänn geworf, obwuel d'Parameteren fir op eng Äntwert ze waarden schonn e puer Mol vergréissert goufen am Verglach mat de Standard.
Ech hoffen, datt mir duerch gemeinsam Efforten d'Flaschenhals vum CS fannen a wa mir et kënne beschleunegen, da wäert ech um Enn vum Post definitiv Informatioun iwwer d'Finale Resultater addéieren.
UPD: Dank de Rot vun de Komeroden hunn ech et fäerdeg bruecht d'Liesen ze beschleunegen. War:
159 Ops (644 Dëscher, 4 Streamen, Batch 5).
Eroflueden:
.withLoadBalancingPolicy(new TokenAwarePolicy(DCAwareRoundRobinPolicy.builder().build()))
An ech hu mat der Unzuel vun de thread gespillt. D'Resultat ass déi folgend:
4 Dëscher, 100 Threads, Batch = 1 (Stéck fir Stéck): 301 ops
4 Dëscher, 100 Threads, Batch = 10: 447 ops
4 Dëscher, 100 Threads, Batch = 100: 625 ops
Méi spéit wäert ech aner Tuning Tipps uwenden, e komplette Testzyklus ausféieren an d'Resultater um Enn vum Post addéieren.
Source: will.com