Princeps effectus est unus de clavibus requisitis cum operando cum magnis data. In notitia loading department apud Sberbank, omnes fere transactiones nostras in Hadoop-substructio Data Cloud sentimus et ideo de magnis informationum fluxibus revera tractamus. Naturaliter vias emendare semper exspectamus, et nunc vobis dicere volumus quomodo nos ad repeciandum Regionis Server HBase ac clientem HDFS tractavimus, quibus gratias signanter augere potuimus celeritatem operationum legendarum.
Sed antequam ad essentiam emendationum progrediatur, de restrictionibus loqui valet quod, in principio, circumveniri non potest si in HDD sederis.
Cur HDD et ieiunium Random Obvius legit non compatitur?
Ut scis, HBase, et multa alia database, in caudices data copia plurium decem chiliobytarum in magnitudine. Defalta est de 64 KB. Nunc fingamus nos tantum 100 bytes acquirere et rogamus HBase ut nobis data hac clavis certa utendo det. Cum magnitudo scandali in HFiles sit 64 KB, petitio 640 temporibus maior (mox minutatim!) quam necessaria erit.
Deinde, cum petitio per HDFS ejusque metadata caching mechanismus ibit ShortcircuitCache (quod directum accessum ad imaginum permittit), hoc ducit ad legendum iam 1 MB ex orbe. Hoc tamen cum modulo accommodari potest dfs.client.read.shortcircuit.buffer.size et in multis casibus sensum hunc valorem reducere facit, exempli gratia ad 126 KB.
Dicamus hoc facere, sed praeterea cum incipimus legere notitias per java api, ut functiones sicut FileChannel.read et rogamus ratio operativa ut certa notitiarum copia legatur, legit "modo in casu" 2 pluries. , i.e. 256 KB in nostro casu. Causa est, quia Java non habet viam facilem ad vexillum FADV_RANDOM ad mores prohibendos.
Quam ob rem, ut nostra 100 bytes, plus mille trecenta sub cucullo legatur. Patet solutio, impedimentum magnitudinis in kilobyte reducamus, vexillum praedictum pone et accelerationem magnam consequamur. Sed molestum est quod reducendo clausuram molem per 2600 tempora, etiam numerum bytes per unitatem temporis per 2 tempora reducimus.
Aliquod lucrum ab occasu Vexillum FADV_RANDOM obtineri potest, sed solum cum multi- tricantis et trunco magnitudinis 128 KB, maximum autem est duorum decem centesimis:
Testimenta super 100 tabulas factae sunt, singulae 1 GB magnitudine et in 10 HDDs positae sunt.
Quod in principio possumus, hanc celeritatem numeremus;
Dicamus nos legisse ex 10 orbe ad celeritatem 280 MB/sec, i.e. 3 decies centies 100 bytes. Sed, ut meminimus, notitia quae nobis necessaria est, MMDC minus est quam id quod legitur. Sic 2600 decies centena millia dividimus et possidemus 1100 records per second.
Deprimendo annon? Quod natura temere accessum accessum ad notitias in HDD - pro scandali magnitudine. Hic est modus physicus accessus incerti ac nullus datorum sub tali condicione plus exprimi potest.
Quomodo ergo databases multo superiores velocitates assequuntur? Ad hanc quaestionem respondendum, inspiciamus quid in sequenti pictura agatur:
Hic videmus pro primis brevibus minutis celeritatem esse vere circiter mille monumentorum secundorum. Porro autem, ob hoc quod multo plus legatur quam petitum est, notitia in alvum/cache systematis operantis (linux) desinit et celeritas ad honestiorem 60 milia per alterum crescit.
Sic porro accessum accelerans agemus solum ad notitias quae in OS cache vel in SSD/NVMe inventa repono accessus celeritatis comparabilis machinis tractabimus.
In nostro casu probationes agemus in consilio servientium 4 , quorum unumquodque hoc modo oneratum est;
CPU: Xeon E5-2680 v4 @2.40GHz 64 stamina.
Memoria: 730. GR.
Java version: 1.8.0_111
Et hic cardinis summa est notitiae in tabulis quae legi debent. Res est quia si legas notitias e tabula quae in HBase cella omnino posita est, tum ne veniat quidem ad legendi bubalinae operantis. Quia HBase per defaltam 40% memoriae ad structuram quae BlockCache allicit. Essentialiter hoc est ConcurrentHashMap, ubi clavis est fasciculi nomen + cinguli claui, et valor notitia actualis sub hac cinguli.
Ita cum ex hac tantum structura legamus ut decies centena millia petitionum secundarum. Sed fingamus nos non posse centum gigabytarum memoriae collocare ad datorum necessitates solum, quia multa sunt alia utilia quae his servientibus currunt.
Exempli causa, volumen BlockCache in uno RS circiter 12 GB. Duo RS una node expositis i.e. 96 GB partita sunt in omnibus nodis BlockCache. Pluresque notitiae sunt, exempli gratia, sint 4 tabulae singulae regiones 130, in quibus fasciculi 800 MB magni sunt, compressi ab FAST_DIFF, i.e. summa 410 GB (hoc est pura notitia, i.e. sine ratione replicationis factor).
Ita, BlockCache solum est circiter 23% totius voluminis notitiae et hoc multo propius ad condiciones reales quae BigData appellatur. Et hoc est ubi incipit iocus - quia patet, quod pauciores hits cache, eo deterius est effectus. Post omnes, si requiro, multum opus habebis — i.e. descende ad munera vocandi ratio. Sed hoc evitari non potest, ut aliam prorsus rationem inspiciamus - quid in notitia intra cella fit?
Rem simplicioremus et sumamus nos habere cella quae 1 objecto tantum aptat. Hoc exemplum eventurum est, cum operam dare conamur cum notitia voluminis 3 temporum amplioribus quam cache, debebimus:
1. Place obstructionum I in cache
2. I de cache Aufer obstructionum
3. Place obstructionum I in cache
4. I de cache Aufer obstructionum
5. Place obstructionum I in cache
5 actus completi! Attamen haec condicio ordinaria dici non potest, immo cogimur HBase ut fasciculum operis omnino inutilis efficiamus. Constanter notitias ex OS cella legit, in BlockCache collocat, solum prope statim projice quod nova portio notitiarum advenit. Animatio in principio tabellae ostendit essentiam problematis - Purgamentum Collector scalmum abiens, atmosphaera calefacit, paulatim Greta in Suetia longinqua et calida turbata est. Et nos IT homines vere non sicut pueri tristes sunt, sic incipimus cogitare quid de eo facere possimus.
Quid, si non omnes clausos in cella ponis, sed tantum quosdam recipis, ut cella non exundet? Incipiamus solum addendo paucas lineas codicis ad principium functionis ad notitias in BlockCache ponendas:
public void cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory) {
if (cacheDataBlockPercent != 100 && buf.getBlockType().isData()) {
if (cacheKey.getOffset() % 100 >= cacheDataBlockPercent) {
return;
}
}
...
Punctum hic tale est: cinguli situs clausus in tabella eiusque digiti postremi passim et aequaliter ab 00 ad 99 distributi sunt. Ergo solum praetermittemus ea quae in ambitum egent.
For example, pone cacheDataBlockPercent = 20 et vide quid accidit;
Ita patet. In graphis infra patebit cur talis acceleratio acciderit - multas facultates GC servamus sine opera Sisyphei data in cella ponendi solum ut statim dejiciat exhauriendum Martiorum canum:
Eodem tempore, CPU utendo augetur, sed multo minus quam fructibus;
Etiam notatu dignum est caudices in BlockCache conditos esse differentes. Maxime, circiter 95%, notitia ipsa est. Reliqua metadata est, ut Filtra Flosculus seu LEAF_INDEX and . Haec notitia non satis est, sed valde utilis est, quia antequam directe accessus notitiarum, HBase vertit ad metam ad intelligendum num opus sit hic ulterius inquirere et, si ita, ubinam usoris interclusus situs est.
Itaque in codice condicionem perspicimus buf.getBlockType (). isData () et propter hanc meta, eam in cella in quolibet casu relinquemus.
Nunc augeamus onus et plumam in uno ite leviter obstringimus. In primo experimento centesimae = 20 intervalli fecimus et BlockCache leviter subutiles erat. Nunc ad 23% eamus, et singulas 100 minutas fila adde 5 ut videam quo in loco saturitas fiat;
Hic videmus versionem originalem paene statim laquearia circiter 100 milia petitionum secundorum attingere. Cum commissura dat accelerationem usque ad CCC milia. Eodem tempore patet ulteriorem accelerationem tam "liberam" non esse, CPU utendo etiam augeri.
Sed haec solutio non admodum elegans est, cum nescimus quid quisque caudices conditivorum sint, id ab oneris figurae dependet. Ideo mechanismus est ad effectum adducendum ut hunc parametrum automatice accommodet secundum operationes operationum legendi.
Tres optiones ad hanc regendam additae sunt:
hbase.lru.cache.heavy.eviction.count.limit — quotiens processus notitiarum elocutionis e cella decurrere debet antequam optimizationem uti incipiamus (i.e. cuneos omissis). Defaltam aequalem MAX_INT = 2147483647 et re vera significat plumam hoc valore laborare numquam. Quia processus evictionis incipit omnis 5 - 10 secundis (dependet ab onere) et 2147483647* 10/ 60/ 60/ 24/ 365 = 680 annorum. Sed hunc modulum ad 0 constituere possumus et pluma operis statim post launch.
Sed in hoc parametro etiam payload est. Si onus nostrum tale est ut breve tempus legit (die interdiu) et diuturnum legit (nocte) assidue intermixtum est, tunc efficere possumus ut pluma in tantum volvatur, cum longae operationes legantur.
Exempli gratia scimus breves lectiones fere 1 minutas durare solere. Non necesse est ut impedimenta abiciendi incipiant, cella non erit tempus ut iam evadatur et tunc hunc modulum aequalem ponere possumus, exempli gratia, 10. Hoc fiet ut optimatio operetur solum cum diuturna. vocabulum activum legere ccepit, i.e. in C seconds. Ita, si breve tempus legitur, omnes caudices in cella intrant et in promptu erunt (exceptis iis quae per algorithmum vexillum evincientur). Et cum longum tempus legit, in pluma vertitur et multo altiores effectus habere volumus.
hbase.lru.cache.heavy.eviction.mb.size.limit — quot megabytes ponit, in cache (et, utique evictionem) in 10 secundis collocare velimus. Pluma hunc valorem assequi conabitur et conservabit. Punctum est hoc: si gigabytes in latibulum trudimus, gigabytes evincere debebimus, et hoc, ut supra vidimus, valde carus est. Nihilominus, non debes eam nimis parvam constituere, sicut hic modus omittitur ad exitum praemature faciendum. Potens servientibus (circiter 20-40 nuclei corporis), optimum est ut circiter 300-400 MB instruat. Pro media materia (~ 10 coros) 200-300 MB. Pro infirmis systematibus (2-5 coros) 50-100 MB normales (non his probatae).
Intueamur quomodo haec opera: dicamus nos hbase.lru.cache.heavy.eviction.mb.size.limit = 500 posuimus, est aliquod genus oneris (lectio) et deinde singula ~10 secunda computamus quot bytes fuerunt eiectis per formulam:
Super caput = Solutus Bytes Sum (MB) * 100 / Limit (MB) - 100;
Si vero MM MB ejiciantur, supra caput æquale est;
2000 * 100 / 500 - 100 = 300%
Algorithmi non plus quam paucas decem centesimas conservare conantur, ideo pluma reduces ad stipites conditivos recipis, ita mechanismum auto-tuning exsequens.
Attamen, si guttae onerariae sunt, dicamus tantum 200 MB evictae et Overhead negativa (sic dicta overshooting):
200 * 100 / 500 - 100 = -60%
E contra, pluma augebit stipites conditivos donec supra caput positivus fiat.
Infra exemplum est quomodo haec notitia realis spectat. Non opus est ut conetur ad 0%, impossibile est. Optimum est, cum circiter 30 - 100%, hoc adiuvat ut praematurum exitum ab ipso modo per breve tempus aestuat exitum vitare.
hbase.lru.cache.heavy.eviction.overhead.coefficient — proficiscitur quam cito exitum obtinere velimus. Si certo scimus legentes nostras plerumque longas esse et expectare nolunt, hanc rationem augere possumus et peractum citius obtinere.
Exempli gratia: hoc coefficiens = 0.01 posuimus. Hoc significat quod supra caput (vide supra) hoc numero multiplicabitur per consequens eventum et recipis stipites conditivos reducetur. Ponamus supra caput = 300% et coefficientem = 0.01, tunc recipis stipites conditivos ab 3% reducendus erit.
Similis "Backpressura" logica etiam in valoribus negativis supra caput (oscendentes) impletur. Cum breve tempus ambigua in volumine lectionum et evictionum semper possibilia sint, haec mechanismus te permittit ut immaturam exitum optimizationis modus vitet. Backpressura logicam inversam habet: quo fortior luxatio, eo plures stipites condiuntur.
Exsequendam codice
LruBlockCache cache = this.cache.get();
if (cache == null) {
break;
}
freedSumMb += cache.evict()/1024/1024;
/*
* Sometimes we are reading more data than can fit into BlockCache
* and it is the cause a high rate of evictions.
* This in turn leads to heavy Garbage Collector works.
* So a lot of blocks put into BlockCache but never read,
* but spending a lot of CPU resources.
* Here we will analyze how many bytes were freed and decide
* decide whether the time has come to reduce amount of caching blocks.
* It help avoid put too many blocks into BlockCache
* when evict() works very active and save CPU for other jobs.
* More delails: https://issues.apache.org/jira/browse/HBASE-23887
*/
// First of all we have to control how much time
// has passed since previuos evict() was launched
// This is should be almost the same time (+/- 10s)
// because we get comparable volumes of freed bytes each time.
// 10s because this is default period to run evict() (see above this.wait)
long stopTime = System.currentTimeMillis();
if ((stopTime - startTime) > 1000 * 10 - 1) {
// Here we have to calc what situation we have got.
// We have the limit "hbase.lru.cache.heavy.eviction.bytes.size.limit"
// and can calculte overhead on it.
// We will use this information to decide,
// how to change percent of caching blocks.
freedDataOverheadPercent =
(int) (freedSumMb * 100 / cache.heavyEvictionMbSizeLimit) - 100;
if (freedSumMb > cache.heavyEvictionMbSizeLimit) {
// Now we are in the situation when we are above the limit
// But maybe we are going to ignore it because it will end quite soon
heavyEvictionCount++;
if (heavyEvictionCount > cache.heavyEvictionCountLimit) {
// It is going for a long time and we have to reduce of caching
// blocks now. So we calculate here how many blocks we want to skip.
// It depends on:
// 1. Overhead - if overhead is big we could more aggressive
// reducing amount of caching blocks.
// 2. How fast we want to get the result. If we know that our
// heavy reading for a long time, we don't want to wait and can
// increase the coefficient and get good performance quite soon.
// But if we don't sure we can do it slowly and it could prevent
// premature exit from this mode. So, when the coefficient is
// higher we can get better performance when heavy reading is stable.
// But when reading is changing we can adjust to it and set
// the coefficient to lower value.
int change =
(int) (freedDataOverheadPercent * cache.heavyEvictionOverheadCoefficient);
// But practice shows that 15% of reducing is quite enough.
// We are not greedy (it could lead to premature exit).
change = Math.min(15, change);
change = Math.max(0, change); // I think it will never happen but check for sure
// So this is the key point, here we are reducing % of caching blocks
cache.cacheDataBlockPercent -= change;
// If we go down too deep we have to stop here, 1% any way should be.
cache.cacheDataBlockPercent = Math.max(1, cache.cacheDataBlockPercent);
}
} else {
// Well, we have got overshooting.
// Mayby it is just short-term fluctuation and we can stay in this mode.
// It help avoid permature exit during short-term fluctuation.
// If overshooting less than 90%, we will try to increase the percent of
// caching blocks and hope it is enough.
if (freedSumMb >= cache.heavyEvictionMbSizeLimit * 0.1) {
// Simple logic: more overshooting - more caching blocks (backpressure)
int change = (int) (-freedDataOverheadPercent * 0.1 + 1);
cache.cacheDataBlockPercent += change;
// But it can't be more then 100%, so check it.
cache.cacheDataBlockPercent = Math.min(100, cache.cacheDataBlockPercent);
} else {
// Looks like heavy reading is over.
// Just exit form this mode.
heavyEvictionCount = 0;
cache.cacheDataBlockPercent = 100;
}
}
LOG.info("BlockCache evicted (MB): {}, overhead (%): {}, " +
"heavy eviction counter: {}, " +
"current caching DataBlock (%): {}",
freedSumMb, freedDataOverheadPercent,
heavyEvictionCount, cache.cacheDataBlockPercent);
freedSumMb = 0;
startTime = stopTime;
}
Nunc omnia hoc exemplo utendo intueamur. Hoc test scriptum habemus:
- Initium facere Scan (stamina 25, batch = 100)
- Post 5 minuta, multi-acquies adde (stamina 25, batch = 100)
- Post V minuta, multi accipit averte (solum adhuc scan manet)
Duas currit, primum hbase.lru.cache.heavy.eviction.count.limit = 10000 (quod actu disable pluma), et deinde terminum = 0 (facit).
In lignis infra videmus quomodo pluma versa est in et reponit transmittens ad 14-71%. Interdum onus decrescit, quod in Backpressure et HBase cella plura impedit.
Iniuriarum RegionServer
evinci (MB): 0, ratio 0.0, capitis (%): -100, grave evictionis contra: 0, caching DataBlock current (%): 100
evinci (MB): 0, ratio 0.0, capitis (%): -100, grave evictionis contra: 0, caching DataBlock current (%): 100
evinci (MB): 2170, ratio 1.09, capitis (%): 985, grave evictionis contra: 1, caching DataBlock current (%): 91 <initium
evinci (MB): 3763, ratio 1.08, supra caput (%): 1781, grave evictionis contra: 2, caching DataBlock vena (%): 76
evinci (MB): 3306, ratio 1.07, supra caput (%): 1553, grave evictionis contra: 3, caching DataBlock vena (%): 61
evinci (MB): 2508, ratio 1.06, supra caput (%): 1154, grave evictionis contra: 4, caching DataBlock vena (%): 50
evinci (MB): 1824, ratio 1.04, supra caput (%): 812, grave evictionis contra: 5, caching DataBlock vena (%): 42
evinci (MB): 1482, ratio 1.03, supra caput (%): 641, grave evictionis contra: 6, caching DataBlock vena (%): 36
evinci (MB): 1140, ratio 1.01, supra caput (%): 470, grave evictionis contra: 7, caching DataBlock vena (%): 32
evinci (MB): 913, ratio 1.0, supra caput (%): 356, grave evictionis contra: 8, caching DataBlock vena (%): 29
evinci (MB): 912, ratio 0.89, supra caput (%): 356, grave evictionis contra: 9, caching DataBlock vena (%): 26
evinci (MB): 684, ratio 0.76, supra caput (%): 242, grave evictionis contra: 10, caching DataBlock vena (%): 24
evinci (MB): 684, ratio 0.61, supra caput (%): 242, grave evictionis contra: 11, caching DataBlock vena (%): 22
evinci (MB): 456, ratio 0.51, supra caput (%): 128, grave evictionis contra: 12, caching DataBlock vena (%): 21
evinci (MB): 456, ratio 0.42, supra caput (%): 128, grave evictionis contra: 13, caching DataBlock vena (%): 20
evinci (MB): 456, ratio 0.33, supra caput (%): 128, grave evictionis contra: 14, caching DataBlock vena (%): 19
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 15, caching DataBlock vena (%): 19
evinci (MB): 342, ratio 0.32, supra caput (%): 71, grave evictionis contra: 16, caching DataBlock vena (%): 19
evinci (MB): 342, ratio 0.31, supra caput (%): 71, grave evictionis contra: 17, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.3, supra caput (%): 14, grave evictionis contra: 18, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.29, supra caput (%): 14, grave evictionis contra: 19, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.27, supra caput (%): 14, grave evictionis contra: 20, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.25, supra caput (%): 14, grave evictionis contra: 21, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.24, supra caput (%): 14, grave evictionis contra: 22, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.22, supra caput (%): 14, grave evictionis contra: 23, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.21, supra caput (%): 14, grave evictionis contra: 24, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.2, supra caput (%): 14, grave evictionis contra: 25, caching DataBlock vena (%): 19
evinci (MB): 228, ratio 0.17, supra caput (%): 14, grave evictionis contra: 26, caching DataBlock vena (%): 19
extrudi (MB): 456, ratio 0.17, capitis (%): 128, grave evictionis contra: 27, caching DataBlock current (%): 18 <accedit additus (sed mensa eadem)
evinci (MB): 456, ratio 0.15, supra caput (%): 128, grave evictionis contra: 28, caching DataBlock vena (%): 17
evinci (MB): 342, ratio 0.13, supra caput (%): 71, grave evictionis contra: 29, caching DataBlock vena (%): 17
evinci (MB): 342, ratio 0.11, supra caput (%): 71, grave evictionis contra: 30, caching DataBlock vena (%): 17
evinci (MB): 342, ratio 0.09, supra caput (%): 71, grave evictionis contra: 31, caching DataBlock vena (%): 17
evinci (MB): 228, ratio 0.08, supra caput (%): 14, grave evictionis contra: 32, caching DataBlock vena (%): 17
evinci (MB): 228, ratio 0.07, supra caput (%): 14, grave evictionis contra: 33, caching DataBlock vena (%): 17
evinci (MB): 228, ratio 0.06, supra caput (%): 14, grave evictionis contra: 34, caching DataBlock vena (%): 17
evinci (MB): 228, ratio 0.05, supra caput (%): 14, grave evictionis contra: 35, caching DataBlock vena (%): 17
evinci (MB): 228, ratio 0.05, supra caput (%): 14, grave evictionis contra: 36, caching DataBlock vena (%): 17
evinci (MB): 228, ratio 0.04, supra caput (%): 14, grave evictionis contra: 37, caching DataBlock vena (%): 17
evinci (MB): 109, ratio 0.04, capitis (%): -46, grave evictionis contra: 37, current caching DataBlock (%): 22 <pressio dorsi
evinci (MB): 798, ratio 0.24, supra caput (%): 299, grave evictionis contra: 38, caching DataBlock vena (%): 20
evinci (MB): 798, ratio 0.29, supra caput (%): 299, grave evictionis contra: 39, caching DataBlock vena (%): 18
evinci (MB): 570, ratio 0.27, supra caput (%): 185, grave evictionis contra: 40, caching DataBlock vena (%): 17
evinci (MB): 456, ratio 0.22, supra caput (%): 128, grave evictionis contra: 41, caching DataBlock vena (%): 16
evinci (MB): 342, ratio 0.16, supra caput (%): 71, grave evictionis contra: 42, caching DataBlock vena (%): 16
evinci (MB): 342, ratio 0.11, supra caput (%): 71, grave evictionis contra: 43, caching DataBlock vena (%): 16
evinci (MB): 228, ratio 0.09, supra caput (%): 14, grave evictionis contra: 44, caching DataBlock vena (%): 16
evinci (MB): 228, ratio 0.07, supra caput (%): 14, grave evictionis contra: 45, caching DataBlock vena (%): 16
evinci (MB): 228, ratio 0.05, supra caput (%): 14, grave evictionis contra: 46, caching DataBlock vena (%): 16
evinci (MB): 222, ratio 0.04, supra caput (%): 11, grave evictionis contra: 47, caching DataBlock vena (%): 16
evinci (MB): 104, ratio 0.03, capitis (%): -48, grave evictionis contra: 47, caching DataBlock current (%): 21 < interrumpere accipit
evinci (MB): 684, ratio 0.2, supra caput (%): 242, grave evictionis contra: 48, caching DataBlock vena (%): 19
evinci (MB): 570, ratio 0.23, supra caput (%): 185, grave evictionis contra: 49, caching DataBlock vena (%): 18
evinci (MB): 342, ratio 0.22, supra caput (%): 71, grave evictionis contra: 50, caching DataBlock vena (%): 18
evinci (MB): 228, ratio 0.21, supra caput (%): 14, grave evictionis contra: 51, caching DataBlock vena (%): 18
evinci (MB): 228, ratio 0.2, supra caput (%): 14, grave evictionis contra: 52, caching DataBlock vena (%): 18
evinci (MB): 228, ratio 0.18, supra caput (%): 14, grave evictionis contra: 53, caching DataBlock vena (%): 18
evinci (MB): 228, ratio 0.16, supra caput (%): 14, grave evictionis contra: 54, caching DataBlock vena (%): 18
evinci (MB): 228, ratio 0.14, supra caput (%): 14, grave evictionis contra: 55, caching DataBlock vena (%): 18
evinci (MB): 112, ratio 0.14, capitis (%): -44, grave evictionis contra: 55, current caching DataBlock (%): 23 <pressio dorsi
evinci (MB): 456, ratio 0.26, supra caput (%): 128, grave evictionis contra: 56, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.31, supra caput (%): 71, grave evictionis contra: 57, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 58, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 59, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 60, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 61, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 62, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 63, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.32, supra caput (%): 71, grave evictionis contra: 64, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 65, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 66, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.32, supra caput (%): 71, grave evictionis contra: 67, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 68, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.32, supra caput (%): 71, grave evictionis contra: 69, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.32, supra caput (%): 71, grave evictionis contra: 70, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 71, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 72, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 73, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 74, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 75, caching DataBlock vena (%): 22
evinci (MB): 342, ratio 0.33, supra caput (%): 71, grave evictionis contra: 76, caching DataBlock vena (%): 22
evinci (MB): 21, ratio 0.33, capitis (%): -90, grave evictionis contra: 76, caching DataBlock current (%): 32
evinci (MB): 0, ratio 0.0, capitis (%): -100, grave evictionis contra: 0, caching DataBlock current (%): 100
evinci (MB): 0, ratio 0.0, capitis (%): -100, grave evictionis contra: 0, caching DataBlock current (%): 100
Lustrationes opus erant ut eundem processum ostenderem in forma graphi relationis inter duas sectiones cachectas - singulas (ubi caudices numquam petiti sunt) et multi (notitia "postulata" saltem semel hic reponuntur);
Denique quid operatio parametri similis sit in lacinia purus. Ad comparationem, latibulum totaliter ab initio avertit, tunc HBase cum caching morabatur et initium operis optimizationis per 5 minutas (30 cyclos evictionis) mittebatur.
Plena codice possunt in excute Request on github.
Nihilominus, trecenta milia per alterum legentium non sunt omnia quae in hoc ferramento his condicionibus effici possunt. Res etenim est cum notitias per HDFS accedere debes, mechanismum ShortCircuitCache (infra postea SSC relatum) adhibitum, quod permittit te ad notitias directe accedere, retiaculorum commercio vitando.
Profiling ostendit quamvis haec mechanismus magnum lucrum dederit, etiam in aliquo puncto fit bottleneck, quia omnes fere graves operationes intra seram occurrunt, quae frequentius interclusionem ducit.
Hoc viso, intelleximus quaestionem circumveniri posse creando aciem SSCs independentium:
private final ShortCircuitCache[] shortCircuitCache;
...
shortCircuitCache = new ShortCircuitCache[this.clientShortCircuitNum];
for (int i = 0; i < this.clientShortCircuitNum; i++)
this.shortCircuitCache[i] = new ShortCircuitCache(…);
Et tunc cum illis laboro, intersectionibus exclusis etiam in novissima digiti cinguli;
public ShortCircuitCache getShortCircuitCache(long idx) {
return shortCircuitCache[(int) (idx % clientShortCircuitNum)];
}
Iam probare potes. Ad hoc faciendum, lima ex HDFS applicatione simplici multi-filata legemus. Parametri constitue:
conf.set("dfs.client.read.shortcircuit", "true");
conf.set("dfs.client.read.shortcircuit.buffer.size", "65536"); // по дефолту = 1 МБ и это сильно замедляет чтение, поэтому лучше привести в соответствие к реальным нуждам
conf.set("dfs.client.short.circuit.num", num); // от 1 до 10
Et mox tabellas lege:
FSDataInputStream in = fileSystem.open(path);
for (int i = 0; i < count; i++) {
position += 65536;
if (position > 900000000)
position = 0L;
int res = in.read(position, byteBuffer, 0, 65536);
}
Hoc signum exercetur in sequelis separatis et numerum imaginum simul legentium augebimus (ab 10 ad 200 - axem horizontalem) et numerum cellarum (ab 1 ad 10 - graphicae). Axis verticalis accelerationem quae consequitur ex incremento SSC respectu casui cum una tantum cella demonstrat.
Quomodo graphi legeretur: Executio tempus pro 100 milibus legit in 64 KB stipitibus cum uno cache requiritur 78 secundis. Sed cum 5 gazophylacio capit XVI secundis. Illae. est acceleratio ~ V temporibus. Ut ex graphe videri potest, effectus non admodum notabilis est ob paucitatem lectionum parallelarum, incipit agere partes notabiles cum plures quam 16 fila legit, etiam notabile est numerum SSCs ab 5 augere. ac supra significanter minoris observantiae incrementum dat.
Nota 1: cum eventus experimenti satis volatiles sunt (vide infra), 3 decurrit effectus et valores inde Curabitur.
Nota II: Procuratio quaestus ex configuratione temere accessus idem est, quamvis accessus ipse paulo tardius sit.
Attamen declarare necesse est hanc accelerationem non semper liberam esse, dissimili casu cum HBase. Hic "recludam" facultatem CPU operandi plus, pro pendens in cincinnis.
Hic animadvertere potes, generatim numerum augeri thesaurorum in CPU utendo augeri proxime proportionalem. Sed leviter magis conciliandae sunt compositiones.
Exempli causa, propius inspiciamus ad occasum SSC = 3. Augmentum effectus in ambitu est circiter 3.3 temporibus. Infra tres omnes eventus sunt.
Dum CPU consummatio crescit circiter 2.8 temporibus. Differentia non valde magna est, sed parva Creta iam laeta est et licet vacare scholam frequentare et lectiones accipere.
Ita hoc effectum positivum habebit pro quovis instrumento quod ad HDFS accessum mole utitur (exempli gratia Spark, etc.), dummodo applicatio codicis leve sit (i.e. obturaculum in latere clientis HDFS) et libera est potentia CPU . Ad reprimendum, experiamur quid efficiat coniunctis usus Optimizationis BlockCache et SSC appitionis legendi ex HBase habebunt.
Ex his condicionibus perspici potest effectum non tam magnum esse quam in probatissimis probatis (lectio sine ullo processu), sed satis possibile est hic 80K adiectis exprimi. Una, utraque optimizations praebent usque ad 4x speedup.
A PR etiam pro hac optimizatione facta est quae inducitur et haec officia in futuris solvo praesto erunt.
Denique studium fuit comparare lectionem similem datorum late columnarum, Cassandrae et HBase.
Ad hoc faciendum, instantias vexillum YCSB oneris probandi utilitatem a duobus exercituum (800 stamina in summa immissis). In server parte - 4 instantiae Regionis Servae et Cassandrae in 4 Exercituum (non sunt ubi clientes currunt, suam potentiam vitant). Lectiones de tabulis magnitudinis;
HBase - 300 GB in HDFS (C GB pura notitia)
Cassandra - 250 GB (replicatio factor = 3)
Illae. volumen idem erat circiter (in HBase paulo plura).
HBase parametri:
dfs.client.short.circuit.num = 5 (HDFS ipsum clientis)
hbase.lru.cache.heavy.eviction.count.limit = 30 - Hoc significat quod commissura incipiet opus post XXX confinia (~ V minuta)
hbase.lru.cache.heavy.eviction.mb.size.limit = 300 - scopum volumen caching et evictionem
Tigna YCSB parsed et in Praecedo graphs exarata sunt:
Ut videre potes, hae optimizationes efficiunt ut harum databases his condicionibus perficiendis compares et per alterum mille legationis CCCCL consequantur.
Speramus haec informationes alicui usui esse posse in certamine excitando pro fructibus.
Source: www.habr.com