web-dev-qa-db-fra.com

Qu'est-ce qu'une tâche dans Spark? Comment le travailleur Spark exécute-t-il le fichier jar?

Après avoir lu un document sur http://spark.Apache.org/docs/0.8.0/cluster-overview.html , j'ai eu une question que je voulais clarifier.

Prenez cet exemple de Spark:

JavaSparkContext spark = new JavaSparkContext(
  new SparkConf().setJars("...").setSparkHome....);
JavaRDD<String> file = spark.textFile("hdfs://...");

// step1
JavaRDD<String> words =
  file.flatMap(new FlatMapFunction<String, String>() {
    public Iterable<String> call(String s) {
      return Arrays.asList(s.split(" "));
    }
  });

// step2
JavaPairRDD<String, Integer> pairs =
  words.map(new PairFunction<String, String, Integer>() {
    public Tuple2<String, Integer> call(String s) {
      return new Tuple2<String, Integer>(s, 1);
    }
  });

// step3
JavaPairRDD<String, Integer> counts =
  pairs.reduceByKey(new Function2<Integer, Integer>() {
    public Integer call(Integer a, Integer b) {
      return a + b;
    }
  });

counts.saveAsTextFile("hdfs://...");

Disons donc que j'ai un cluster à 3 nœuds et que le nœud 1 fonctionne en tant que maître et que le programme de pilote ci-dessus a été correctement corrigé (par exemple, application-test.jar). Alors maintenant, j'exécute ce code sur le nœud maître et je crois que juste après la création du SparkContext, le fichier application-test.jar sera copié sur les nœuds de travail (et chaque travailleur créera un répertoire pour cette application).

Alors maintenant ma question: est-ce que step1, step2 et step3 dans les tâches d'exemple qui sont envoyées aux travailleurs? Si oui, comment le travailleur exécute-t-il cela? Comme Java -cp "application-test.jar" step1 etc?

apache-sparkdistributed-computing
43
EdwinGuo

Lorsque vous créez le SparkContext, chaque travailleur démarre un exécuteur . Il s'agit d'un processus distinct (JVM) et il charge également votre bocal. Les exécuteurs se reconnectent à votre programme de pilotes. Maintenant, le pilote peut leur envoyer des commandes, comme flatMap, map et reduceByKey dans votre exemple. Lorsque le pilote quitte, les exécuteurs exécutent l'arrêt.

Les RDD sont un peu comme de grands tableaux qui sont divisés en partitions, et chaque exécuteur peut contenir certaines de ces partitions.

Un tâche est une commande envoyée du pilote à un exécuteur en sérialisant votre objet Function. L'exécuteur désérialise la commande (cela est possible car il a chargé votre jar) et l'exécute sur une partition.

(Il s'agit d'un aperçu conceptuel. Je passe sous silence certains détails, mais j'espère que cela vous sera utile.)

Pour répondre à votre question spécifique: Non, un nouveau processus n'est pas démarré pour chaque étape. Un nouveau processus est démarré sur chaque travailleur lorsque le SparkContext est construit.

96
Daniel Darabos

Pour avoir une idée claire de la façon dont les tâches sont créées et planifiées, nous devons comprendre le fonctionnement du modèle d'exécution dans Spark. En bref, une application en spark est exécutée en trois étapes:

  1. Créer un graphique RDD
  2. Créez un plan d'exécution selon le graphique RDD. Les étapes sont créées à cette étape
  3. Générez des tâches en fonction du plan et planifiez-les entre les employés

Dans votre exemple de comptage de mots, le graphique RDD est plutôt simple, c'est quelque chose comme suit:

fichier -> lignes -> mots -> nombre par mot -> nombre global de mots -> sortie

Sur la base de ce graphique, deux étapes sont créées. La règle de création d'étape est basée sur l'idée de canaliser autant de transformations étroites que possible. Dans votre exemple, la transformation étroite se termine au nombre par mot. Par conséquent, vous obtenez deux étapes

  1. fichier -> lignes -> mots -> nombre par mot
  2. nombre de mots global -> sortie

Une fois les étapes définies, spark générera des tâches à partir des étapes. La première étape créera ShuffleMapTasks et la dernière étape créera ResultTasks car dans la dernière étape, une opération d'action est incluse pour produire des résultats.

Le nombre de tâches à générer dépend de la façon dont vos fichiers sont distribués. Supposons que vous ayez 3 trois fichiers différents dans trois nœuds différents, la première étape générera 3 tâches: une tâche par partition.

Par conséquent, vous ne devez pas mapper directement vos étapes aux tâches. Une tâche appartient à une étape et est liée à une partition.

Habituellement, le nombre de tâches exécutées pour une étape est exactement le nombre de partitions du RDD final, mais comme les RDD peuvent être partagés (et donc ShuffleMapStages), leur nombre varie en fonction du partage RDD/étape. Veuillez vous référer à Comment fonctionne DAG sous les couvertures de RDD?

32
Hui Wang