Analyse approfondie des composants principaux de Spark
1. Mécanisme de stockage et de gestion des données BlockManager
BlockManager est un composant responsable du stockage et de la gestion des données au bas de Spark. Toutes les données du Driver et de l'Executor sont gérées par le BlockManager correspondant.
Il y a BlockManagerMaster sur le pilote, qui est responsable de la gestion des métadonnées des données gérées par le BlockManager sur chaque nœud. Par exemple, les opérations telles que les ajouts, les suppressions et les modifications de blocs conserveront les changements de métadonnées ici.
Chaque nœud a un BlockManager. Après la création de chaque BlockManager, la première chose à faire est de s'enregistrer auprès de BlockManagerMaster, et BlockManagerMaster créera un BlockManagerInfo correspondant.
Le principe de fonctionnement de BlockManager est illustré dans la figure suivante:
La relation entre BlockManagerMaster et BlockManager est très similaire à la relation entre NameNode et DataNode BlockManagerMaster 中保存中 BlockManager 内部管理数据的元数据，进行维护，当BlockManager 进行 Block 增删改等操作时，都会在 BlockManagerMaster 中进行元数据的变更. Ceci est cohérent avec le NameNode qui conserve les informations de métadonnées du DataNode. Lorsque les données du DataNode changent, les informations de métadonnées du NameNode changent également en conséquence. de.
Il y a un BlockManager sur chaque nœud, et il y a 3 composants très importants dans le BlockManager:
(1)
DiskStore: Responsable de la lecture et de l'écriture des données du disque;
(2)MemoryStore: Responsable de la lecture et de l'écriture des données de mémoire;
(3)BlockTransferService: Responsable de l'établissement de la connexion de BlockManager au BlockManager d'autres nœuds distants, et responsable du traitement des données de BlockManager d'autres nœuds distants Lire et écrire
每个 BlockManager 创建之后，做的第一件事就是向 BlockManagerMaster 进行注册，此时 BlockManagerMaster 会为其创建对应的 BlockManagerInfo。
Lorsque vous utilisez BlockManager pour écrire des opérations, par exemple, des données intermédiaires pendant l'opération RDD, ou si nous spécifions manuellement persist (), les données seront d'abord écrites dans la mémoire. Si la taille de la mémoire n'est pas suffisante, il utilisera son propre algorithme pour enregistrer la mémoire. Une partie des données est écrite sur le disque; de plus, si persist () spécifie de répliquer, BlockTransferService sera utilisé pour répliquer les données vers le BlockManager d'autres nœuds.
Lorsque vous utilisez BlockManager pour des opérations de lecture, par exemple, pour des opérations shuffleRead, s'il peut être lu localement, utilisez DiskStore ou MemoryStore pour lire les données localement, mais s'il n'y a pas de données localement, BlockTransferService sera utilisé pour établir une connexion avec le BlockManager qui a des données, puis Utilisez BlockTransferService pour lire les données du BlockManager distant. Par exemple, dans l'opération de lecture aléatoire, il est très probable que les données à extraire ne soient pas disponibles localement, puis elles iront au nœud distant avec les données et trouveront le BlockManager de ce nœud pour extraire les données requises.
只要使用 BlockManager 执 行 了 数 据 增 删 改 的 操 作 ， 那 么 必 须 将 Block 的BlockStatus 上报到 BlockManagerMaster ， 在 BlockManagerMaster 上会对指定BlockManager 的 BlockManagerInfo 内部的 BlockStatus 进行增删改操作，从而达到元数据的维护功能。
2. L'implémentation sous-jacente des variables partagées Spark
Une caractéristique très importante de Spark est que 共享变量.
Par défaut, si une variable externe est utilisée dans la fonction d'un opérateur, alors
la valeur de cette variable sera modifiée 被拷贝到每个 task 中et chaque tâche ne pourra exploiter que sa propre copie de la variable. Si
plusieurs tâches souhaitent partager une variable, cette approche est impossible.
Spark fournit deux variables partagées à cet effet:
（1） Variable de diffusion （
广播变量）
（2） Accumulateur （
累加变量）
La variable de diffusion ne copiera que les variables utilisées pour chaque nœud, à savoir每个 Executor 拷贝一份，更大的用途是优化性能，减少网络传输以及内存损耗。
L'accumulateur peut 让多个 task 共同操作一份变量, principalement pour les opérations d'accumulation. La variable de diffusion est une variable de lecture partagée, la tâche ne peut pas la modifier et Accumulator peut autoriser plusieurs tâches à manipuler une variable.
2.1 Variables de diffusion
Diffusez des variables 允许编程者在每个 Executor 上保留外部数据的只读变量au lieu d'envoyer une copie à chaque tâche.
Chaque tâche enregistre une copie des variables externes qu'elle utilise. Lorsque plusieurs tâches d'un exécuteur utilisent une grande variable externe, la consommation de mémoire de l'exécuteur est très importante. Par conséquent, nous pouvons modifier la grande variable externe Encapsulé en tant que variable de diffusion. À ce stade, un exécuteur enregistre une copie de la variable. Toutes les tâches de cet exécuteur partagent cette variable. L'enregistrement d'une copie n'est plus une tâche unique. Cela réduit dans une certaine mesure l'utilisation de la mémoire des tâches Spark.
La tâche utilise des variables externes: La
tâche utilise des variables de diffusion:
Spark tente également d'utiliser des algorithmes de diffusion efficaces pour distribuer des variables de diffusion afin de réduire les coûts de communication.
La variable de diffusion fournie par Spark est oui 只读et 在每个 Executor 上只会有一个副本ne fait pas de copie de chaque tâche. Par conséquent, son plus grand effet : 减少变量到各个节点的网络传输消耗，以及在各个节点上的内存消耗。en outre, Spark utilise également un algorithme de diffusion efficace pour réduire la consommation du réseau.
Vous pouvez créer une variable de diffusion pour chaque variable en appelant la méthode broadcast () de SparkContext. Ensuite, dans la fonction de l'opérateur, lorsque la variable de diffusion est utilisée, chaque exécuteur ne fera qu'une copie, et chaque tâche peut utiliser la méthode value () de la variable de diffusion pour obtenir la valeur.
Lorsque la tâche est en cours d'exécution, l'exécuteur n'obtient pas la variable de diffusion. Lorsque la tâche exécute le code qui utilise la variable de diffusion, elle demande la variable de diffusion à la mémoire de l'exécuteur, comme illustré dans la figure suivante:
Ensuite, l'exécuteur extrait la variable de diffusion du pilote via le BlockManager. Ensuite, fournissez-le à la tâche à utiliser, comme illustré dans la figure suivante:
Les variables de diffusion sont une méthode d'optimisation de base couramment utilisée dans Spark 通过减少内存占用实现任务执行性能的提升.
2.2 Accumulateur
Accumulateur: L'accumulateur est 仅仅被相关操作累加的变量, donc il peut être efficacement pris en charge en parallèle. ils可用于实现计数器（如 MapReduce）或总和计数。
Accumulator 是存在于 Driver 端的，集群上运行的 task 进行 Accumulator 的累加，随后把值发到 Driver 端，在 Driver 端汇总(Spark UI est créé lors de la création de SparkContext, c'est-à-dire qu'il est créé du côté du pilote, afin qu'il puisse lire la valeur de l'accumulateur),由于 Accumulator存在于 Driver 端，从节点读取不到 Accumulator 的数值。
Spark 提供的 Accumulator 主要用于多个节点对一个变量进行共享性的操作。Accumulator ne fournit que la fonction d'accumulation, mais il nous fournit la fonction d'opération parallèle de plusieurs tâches sur la même variable Cependant task 只能对 Accumulator 进行累加操作，不能读取它的值, seul le programme Driver peut lire la valeur de Accumulator.
Le principe sous-jacent de l'accumulateur est illustré dans la figure ci-dessous:
