Me estoy haciendo un poco de ajuste de memoria en mi Chispa de trabajo en el HILO y veo una configuración diferente podría dar resultados diferentes y afectar el resultado de la Chispa de la ejecución de la tarea. Sin embargo, estoy confundido y no entiende completamente por qué ocurre esto y agradecería si alguien puede proporcionarme un poco de orientación y explicación.

Voy a proporcionar algunos antecedentes de la información y de publicar mis preguntas y describir los casos que yo he experimentado después de ellos a continuación.

Mi configuración del entorno fueron de la siguiente manera:

  • Memoria 20G, 20 VCores por nodo (3 nodos en total)
  • Hadoop 2.6.0
  • Chispa 1.4.0

Mi código de forma recursiva los filtros de un dispositivo de este tipo para hacerla más pequeña (la eliminación de los ejemplos, como parte de un algoritmo), entonces ¿mapToPair y recoger a recoger los resultados y guardarlos dentro de una lista.

Preguntas

  1. ¿Por qué es un error diferente tirado y se ejecuta el trabajo (para el segundo caso) entre el primer y segundo caso, con sólo el ejecutor de la memoria se incrementa? Son los dos errores vinculados de alguna manera?

  2. Tanto en el tercer y cuarto caso se realiza correctamente y entiendo que es porque me estoy dando más memoria de la que soluciona los problemas de memoria. Sin embargo, en el tercer caso,

chispa.el controlador.memoria + chispa.hilo.el controlador.memoryOverhead = la memoria
que HILO de crear una JVM

= 11g + (driverMemory * 0.07, con un mínimo de 384m)
= 11g + 1.154 g
= 12.154 g

Así, a partir de la fórmula, puedo ver que mi trabajo requiere MEMORY_TOTAL de alrededor de 12.154 g se ejecute correctamente, lo que explica por qué necesito más de 10g para el controlador de memoria de configuración.

Pero para el cuarto caso,

chispa.el controlador.memoria + chispa.hilo.el controlador.memoryOverhead = la memoria
que HILO de crear una JVM

= 2 + (driverMemory * 0.07, con un mínimo de 384m)
= 2g + 0.524 g
= 2.524 g

Parece que sólo por el aumento de la sobrecarga de la memoria por una pequeña cantidad de 1024(1g) que conduce a la correcta ejecución del trabajo con el controlador de memoria de sólo 2g y el MEMORY_TOTAL es sólo 2.524 g! Mientras que sin la sobrecarga de la configuración, el controlador de memoria de menos de 11 g falla, pero no tiene sentido a partir de la fórmula que es la razón por la que estoy confundido.

Por qué el aumento de la sobrecarga de la memoria (para el conductor y el ejecutor) permite mi trabajo para completar con éxito con un menor MEMORY_TOTAL (12.154 g vs 2.524 g)? Hay algunas otras cosas internas en el trabajo aquí que me estoy perdiendo?

Primer Caso

/bin/spark-submit --class <class name> --master yarn-cluster --driver-memory 7g --executor-memory 1g --num-executors 3 --executor-cores 1 --jars <jar file>

Si puedo ejecutar mi programa con cualquier controlador de memoria de menos de 11g, obtengo el siguiente error, que es el SparkContext ser detenido o un error similar, que es un método que se llama en un detenido SparkContext. De lo que he reunido, esto está relacionado con la memoria, no siendo suficiente.

Apache Spark Efectos de la Memoria del Controlador, el Ejecutor de la Memoria, Controlador de Sobrecarga de la Memoria y el Ejecutor de la Sobrecarga de la Memoria en el éxito del trabajo se ejecuta

Segundo Caso

/bin/spark-submit --class <class name> --master yarn-cluster --driver-memory 7g --executor-memory 3g --num-executors 3 --executor-cores 1 --jars <jar file>

Si ejecuto el programa con el mismo controlador de memoria, pero de mayor ejecutor de la memoria, se ejecuta el trabajo más largo (unos 3-4 minutos) que en el primer caso y, a continuación, se va a encontrar con un error diferente de la anterior, que es un Contenedor de solicitar/el uso de más memoria de lo permitido y que se mató por eso. Aunque me parece extraño ya que el ejecutor de la memoria es mayor y se produce este error, en lugar de un error, en el primer caso.

Apache Spark Efectos de la Memoria del Controlador, el Ejecutor de la Memoria, Controlador de Sobrecarga de la Memoria y el Ejecutor de la Sobrecarga de la Memoria en el éxito del trabajo se ejecuta

Tercer Caso

/bin/spark-submit --class <class name> --master yarn-cluster --driver-memory 11g --executor-memory 1g --num-executors 3 --executor-cores 1 --jars <jar file>

Cualquier configuración con el controlador de memoria de más de 10g llevará al trabajo, siendo capaz de ejecutar con éxito.

Cuarto Caso

/bin/spark-submit --class <class name> --master yarn-cluster --driver-memory 2g --executor-memory 1g --conf spark.yarn.executor.memoryOverhead=1024 --conf spark.yarn.driver.memoryOverhead=1024 --num-executors 3 --executor-cores 1 --jars <jar file>

El trabajo se ejecuta con éxito con esta configuración (controlador de memoria de 2g y ejecutor de la memoria de 1g, pero el aumento de la memoria del controlador de la cabeza(1g) y el ejecutor de sobrecarga de la memoria(1g).

Cualquier ayuda será apreciada y realmente me ayuda con mi comprensión de la Chispa. Gracias de antemano.

InformationsquelleAutor t22000 | 2015-08-30

1 Comentario

  1. 7

    Todos sus casos de uso

    --executor-cores 1
    

    Es la mejor práctica para ir por encima de 1. Y no se vaya por encima de 5.
    A partir de nuestra experiencia y de la Chispa de los desarrolladores de recomendación.

    E. g.
    http://blog.cloudera.com/blog/2015/03/how-to-tune-your-apache-spark-jobs-part-2/
    :

    A rough guess is that at most five tasks per executor 
    can achieve full write throughput, so it’s good to keep 
    the number of cores per executor below that number
    

    No puedo encontrar ahora de referencia donde se recomienda ir por encima de 1 núcleos por el ejecutor. Pero la idea es que la ejecución de múltiples tareas en el mismo ejecutor le da la posibilidad de compartir algunas regiones de memoria por lo que en realidad guarda la memoria.

    Empezar con –ejecutor-2 núcleos, doble –ejecutor de la memoria (porque-ejecutor-núcleos dice también cómo muchas de las tareas que un ejecutor de la voluntad de ejecutar concurently), y ver lo que hace para usted. Su entorno es compacto en términos de memoria disponible, así que va a 3 o 4 le dará una mejor utilización de la memoria.

    Utilizamos Chispa 1.5 y dejó de usar –ejecutor-núcleos 1 hace bastante tiempo ya que estaba dando GC problemas; se ve también como una Chispa error, porque acaba de dar más memoria no estaba ayudando en la medida que cambiar para tener más tareas por contenedor. Supongo tareas en el mismo ejecutor puede máximo su consumo de memoria en diferentes momentos, para no perder/no tiene a general hay sobre oferta de la memoria sólo para hacer el trabajo.

    Otro beneficio es que la Chispa de variables compartidas (acumuladores y de difusión de las variables) será de sólo una copia de cada ejecutor, no por tarea – para cambiar a varias tareas por el ejecutor directo del ahorro de memoria a la derecha allí. Incluso si usted no usa la Chispa de las variables compartidas de forma explícita, la Chispa muy probable que crea internamente de todos modos. Por ejemplo, si usted unir dos tablas a través de la Chispa de SQL, la Chispa de la CBO podrá decidir la emisión de una mesa más pequeña (o un pequeño dataframe), para dar a unirse a correr más rápido.

    http://spark.apache.org/docs/latest/programming-guide.html#shared-variables

    • Esta no es una respuesta para el conductor de sobrecarga de la memoria vs controlador de memoria de la pregunta, este comportamiento es todavía abierta la cuestión creo

Dejar respuesta

Please enter your comment!
Please enter your name here