¿Qué algoritmo utiliza Spark para identificar claves similares y llevar los datos a la siguiente etapa?
Los escenarios incluyen,
Cuando aplico distintivo(), sé que se aplicó una predistinción en la etapa actual y luego los datos se barajan a la siguiente etapa. En este caso, todas las claves similares deben estar en la misma partición en la siguiente etapa.
Cuando Dataset1 se une con Dataset2 (SortMergeJoin). En este caso, todas las claves similares en Dataset1 y Dataset2 deben estar en la misma partición en la siguiente etapa.
Hay otros escenarios también, pero el panorama general es este.
¿Cómo hace Spark esto de manera eficiente? ¿Habrá algún desfase entre la Etapa 1 y la Etapa 2 al identificar claves similares?
------------------------------------
El algoritmo que Spark utiliza para particionar los datos es Hash de forma predeterminada. Además, las etapas no empujan sino que extraen los datos de la etapa anterior.
Spark crea límites de escenario cada vez que se necesita una mezcla. La segunda etapa esperará hasta que se completen todas las tareas de la primera etapa y escribirá su salida en archivos temporales. Luego, la segunda etapa comienza a extraer los datos necesarios para sus particiones de todas las particiones escritas en la etapa 1.
Distinto como ves no es tan simple como parece. Spark se diferencia aplicando agregados. También es necesario barajar porque los duplicados pueden estar en varias particiones. Una de las condiciones para la mezcla es que Spark necesita un par de RDD y, si su padre no lo es, lo creará enRDD de par intermediario.
Si ves el plan lógico de Distinct, sería más o menos como
RDD principal ---> RDD asignado (registrar como clave y valores nulos) ---> MapPartitionsRDD (ejecutándose distinto a nivel de partición) ----> RDD aleatorio (extrayendo datos de particiones necesarios) ----> MapPartitionsRDD (distinto de particiones segregadas para cada clave) ----> RDD asignado (recopila solo claves y descarta valores nulos para el resultado)
------------------------------------
Spark utiliza la dependencia RDD para lograr que los datos se transfieran a la siguiente etapa. Y saber cuál es un proceso complejo;
La función getDependenciasen RDD.SCALA es responsable de obtener los datos de los padres.
/**
* Implemented by subclasses to return how this RDD depends on parent RDDs. This method will only
* be called once, so it is safe to implement a time-consuming computation in it.
*/
protected def getDependencies: Seq[Dependency[_]] = deps
Y algunos RDD no tienen que obtener el RDD principal, por lo que el RDD no implementa la función de cálculo, como DataSource RDD;
Shuffle RowRDD generalmente aparece en el cálculo en cadena, por lo que generalmente tiene los datos principales para recuperar.
