Demystifying Partitioning sa Spark



Sinasabi sa iyo ng blog na ito ang kailangan mong malaman tungkol sa pagkahati sa Spark, mga uri ng pagkahati at kung paano nito pinapabuti ang bilis ng pagpapatupad para sa mga pangunahing pagbagong pagbabago.

Ibinigay ni Prithviraj Bose

Spark's Nababanat na Ipinamahaging Mga Dataset (ang abstraction ng programa) ay tinatasa nang tamad at ang mga pagbabago ay nakaimbak bilang nakadirekta na mga acyclic graph (DAG). Kaya't ang bawat pagkilos sa RDD ay gagawing muli sa Spark ang DAG. Ito ay kung paano nakamit ang katatagan sa Spark dahil kung ang anumang node ng manggagawa ay nabigo sa gayon ang DAG ay kailangang muling makamit.





Ito rin ay sapilitan sa cache (magpumilit sa naaangkop na antas ng pag-iimbak) ang RDD na tulad ng madalas na mga pagkilos sa RDD ay hindi pinipilit ang Spark na muling ibalik ang DAG.Ang mga paksang sakop sa blog na ito ay mahalagang kinakailangan para sa Apache Spark at Scala Certification. Ang mga paksang sakop sa blog na ito ay mahalagang kinakailangan .

Bakit Gumagamit ng isang Paghahati?

Sa computing computing, ang pangunahing hamon ay i-minimize ang trapiko sa network. Kapag ang data ay nakatuon sa key-halaga, ang pagkahati ay naging kinakailangan dahil para sa kasunod na mga pagbabago sa RDD, mayroong isang patas na halaga ng paglilipat ng data sa buong network. Kung ang mga katulad na susi o saklaw ng mga susi ay nakaimbak sa parehong pagkahati pagkatapos ang shuffling ay nai-minimize at ang pagpoproseso ay naging malaki mabilis.



Ang mga pagbabago na nangangailangan ng paglilipat ng data sa mga node ng manggagawa ay lubos na nakikinabang sa pagkahati. Ang ganitong mga pagbabago ay cogroup, groupWith, sumali, kaliwaOuterJoin, kananOuterJoin, groupByKey, bawasanByKey, pagsamahinByKey at lookup .

kung paano wakasan ang isang programang java
Ang mga partisyon ay maaaring mai-configure kung ang RDD ay batay sa key-value.

Mga Katangian ng Paghahati

  1. Ang mga Tuple sa parehong pagkahati ay ginagarantiyahan na nasa parehong makina.
  2. Ang bawat node sa isang kumpol ay maaaring maglaman ng higit sa isang pagkahati.
  3. Ang kabuuang bilang ng mga partisyon ay maaaring mai-configure, bilang default na ito ay nakatakda sa kabuuang bilang ng mga core sa lahat ng mga node ng tagapagpatupad.

Mga uri ng Paghahati sa Spark

Sinusuportahan ng Spark ang dalawang uri ng pagkahati,

  • Hash Partitioning : Gumagamit ng Java's Bagay.hashCode pamamaraan upang matukoy ang pagkahati bilang pagkahati = key.hashCode ()% numPartitions.

hash-partitioning-demystifying-partitioning-in-spark



  • Saklaw na Paghahati : Gumagamit ng isang saklaw upang ipamahagi sa kani-kanilang mga pagkahati ang mga susi na nahuhulog sa loob ng isang saklaw. Angkop ang pamamaraang ito kung saan mayroong natural na pag-order sa mga susi at ang mga pindutan ay hindi negatibo. Ipinapakita ng snippet ng code sa ibaba ang paggamit ng partitioner ng saklaw.

Halimbawa ng Code

Tingnan natin ang isang halimbawa sa kung paano maghiwalay ng data sa mga node ng manggagawa. Magagamit ang buong Scala code dito .

Narito ang ilang data ng pagsubok ng 12 mga coordinate (bilang mga tuple),

Lumikha ng isang org.apache.spark.HashPartitioner ng laki 2, kung saan ang mga pindutan ay mai-partition sa kabuuan ng dalawang partisyon batay sa hash code ng mga key.

Pagkatapos ay maaari naming siyasatin ang mga pares at gumawa ng iba't ibang mga pangunahing batay sa mga pagbabago tulad foldByKey at bawasanByKey.

Ang pagbubuod, paghati ay lubos na nagpapabuti ng bilis ng pagpapatupad para sa mga pangunahing batay sa mga pagbabago.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento at babalikan ka namin.

kung paano itakda ang java classpath

Mga Kaugnay na Post:

Bakit Dapat Mong Malaman ang Spark Pagkatapos Ng Pagkontrol sa Hadoop

Apache Spark Vs Hadoop MapReduce