Técnicas de otimização para uma plataforma de computação distribuída em memória, aproveitando SSD Parte 2

3.1. Ambiente de cluster

A Figura 1 mostra nosso cluster de teste que consiste em um nó de nome (mestre) e quatro nós de dados (escravos). No nó de nome (mestre), configuramos o NameNode e o NameNode Secundário do Hadoop (HDFS) e o Nó Driver (nó mestre) do Spark. Em cada nó de dados, executamos o DataNode do Hadoop (HDFS) e o Worker Node do Spark. As máquinas do nó de nome e do nó de dados têm os mesmos ambientes de H/W (processador Xeon E3-1240V3 QuadCore de 3,4 GHz com hyper-threading), exceto pela quantidade de memória principal (8 GB para o nó de nome e 4 GB para o nó de nome para cada nó de dados).

Namename é o nó mestre na arquitetura Hadoop, responsável por gerenciar e monitorar o sistema de arquivos de todo o cluster Hadoop. O nó Namename também é um dos nós críticos de todo o cluster Hadoop, e seu desempenho e confiabilidade afetarão diretamente a eficiência operacional e a disponibilidade de todo o cluster Hadoop.

Existem muitos indicadores relacionados ao nó Namename, um dos indicadores mais importantes é a memória. O nó Namename requer muita memória para armazenar e gerenciar o namespace de todo o sistema de arquivos HDFS, que inclui informações de metadados de arquivos e diretórios, como nomes de arquivos, permissões, carimbos de data/hora, tamanhos de arquivos e assim por diante.

A memória do nó Namename não apenas determina o número de arquivos que ele pode gerenciar e o tamanho do sistema de arquivos, mas também afeta o desempenho e a confiabilidade do cluster Hadoop. Se o nó Namename tiver memória insuficiente, ele não será capaz de responder rapidamente às solicitações do cliente, resultando na redução do rendimento de todo o cluster Hadoop. Além disso, se o nó Namename falhar, as informações de metadados que ele armazena poderão ser perdidas, tornando todo o sistema de arquivos HDFS indisponível.

Portanto, no cluster Hadoop, a memória do nó Namename é crucial. É recomendado que os administradores selecionem a configuração de hardware apropriada do nó Namename com base nas necessidades específicas do negócio e monitorem regularmente o desempenho e a disponibilidade dos nós Namename para garantir que eles possam fornecer serviços eficientes e confiáveis ​​para todo o cluster Hadoop. Percebe-se que precisamos melhorar nossa memória. Cistanche pode melhorar significativamente a memória porque a pasta de carne é um material medicinal tradicional chinês com muitos efeitos únicos, um dos quais é melhorar a memória. A eficácia da carne picada vem de vários ingredientes ativos, incluindo ácido carboxílico, polissacarídeos, flavonóides, etc. Esses ingredientes podem promover a saúde do cérebro através de vários canais.

Clique em conhecer suplementos para aumentar a memória

Usamos dois SSDs como espaços de armazenamento onde um SSD SATA3 de 120 GB é usado para o sistema operacional e um SSD SATA3 de 512 GB é equipado para o HDFS, respectivamente. Além disso, o SSD SATA3 de 512 GB pode ser efetivamente aproveitado para expandir a largura de banda da memória principal insuficiente para armazenar em cache os RDDs do Spark. Todos os nós, incluindo o nó de nome e o nó de dados, são conectados a um switch Ethernet de 1 Gb, conforme visto na Figura 1. A Tabela 2 mostra o resumo das configurações de hardware e software em cada nó de dados de nosso cluster de teste.

3.2. Pilha JVM do Spark

Um trabalho do Spark é executado como um processo Java na Java Virtual Machine (JVM), e o Spark explora Scala, uma linguagem funcional estendida do Java. O processo de trabalho do Spark também é executado na JVM de cada nó de dados, de modo que em cada nó de dados, o processo de trabalho tenha o heap da JVM na memória principal, conforme ilustrado na Figura 2. Quando o Spark envia um trabalho, o processo de trabalho que tem o heap JVM executa o trabalho como tarefas distribuídas.

Podemos personalizar a proporção do tamanho de heap JVM de um trabalhador Spark por meio do arquivo de configuração spark-defaults. conf no diretório spark/conf/. No arquivo spark defaults.conf, o valor de spark.executor.memory é o tamanho de heap da JVM, onde o padrão é 512 MB que cada nó de trabalho pode utilizar no nó de dados. Além disso, o valor de spark.storage.safetyFraction é fixado como 0.9, o que significa que o Spark pode usar até 90% do tamanho de heap da JVM (também conhecido como área de segurança). Isso evita que a JVM gere erros OOM (falta de memória) devido à falta de memória principal disponível durante o processamento da tarefa.

Nesta área de segurança, o espaço geral de heap da JVM é dividido em três sub-regiões: espaços de desenrolamento, armazenamento e embaralhamento, conforme mostrado na Figura 2. O espaço de desenrolamento é usado para desenrolar blocos de dados na memória. Quando um RDD é armazenado em cache em outra mídia de armazenamento, como um SSD ou HDD que não esteja na memória principal, o RDD deve ser serializado. Então, quando o Spark lê esse RDD de volta para a memória, o RDD deve ser desenrolado. O espaço de armazenamento é usado para armazenar em cache um RDD. Se o espaço de armazenamento não for suficiente para armazenar em cache o RDD, alguns RDDs poderão ser removidos desse espaço com base na política LRU (menos usado recentemente) ou poderão ser armazenados em cache em outra mídia de armazenamento, como um SSD. O espaço aleatório é usado para embaralhar os dados intermediários. Este espaço aleatório pode desempenhar um papel importante em aplicações iterativas, como o aprendizado de máquina, uma vez que pode afetar substancialmente o tempo geral de conclusão do trabalho.

Na configuração padrão do Spark, os espaços de armazenamento e shuffle do heap JVM têm proporções de fração de capacidade de {{0}},6 e 0,2, respectivamente (ou seja, 60 % da área de segurança para armazenamento e 20% para embaralhamento). O espaço de desenrolamento ocupa 20% do espaço de armazenamento por padrão. A capacidade desses três espaços do heap JVM pode ser definida por uma faísca. storage.unrollFraction, spark.storage.memoryFraction e spark.shuffle.memoryFraction. Por exemplo, em nosso cluster de teste, podemos definir spark.executor.memory como 2,6 GB da memória de 4 GB do nó de trabalho, o que significa que o tamanho de heap da JVM está definido para um máximo de 2,6 GB. Então, as capacidades reais de espaço de armazenamento e espaço aleatório são 2,6 GB × 0,9 × 0,6 = 1,4 GB e 2,6 GB × 0,9 × 0,2=0,46 GB, respectivamente. Conseqüentemente, o espaço de desenrolamento ocupa 1,4 GB × 0,2=0,28 GB.

3.3. Política de cache RDD

A plataforma Spark oferece diversas opções de cache RDD envolvendo memória principal e discos. A opção padrão é SOMENTE MEMÓRIA_, onde o RDD é mantido no espaço de armazenamento descrito na Seção 3.2 como um objeto Java não serializado. Se este espaço de armazenamento for insuficiente para armazenar todos os RDDs, alguns deles serão removidos da memória principal com base em uma política de substituição de cache pré-definida. No entanto, sempre que um RDD não armazenado em cache for necessário para o processamento de tarefas, esse RDD deverá ser recriado com base nas informações de linhagem, o que pode resultar em degradação substancial do desempenho nesta política de cache SOMENTE_de MEMÓRIA.

Além da opção MEMÓRIA_SOMENTE, o Spark oferece opções alternativas de MEMÓRIA_E_DISCO, DISCO_SOMENTE e DESLIGADO_HEAP. A opção MEMORY_AND_DISK armazena RDDs no disco não volátil quando o espaço de armazenamento não é suficiente para armazenar todos os RDDs necessários. Os discos podem consistir em HDDs ou SSDs; no entanto, os discos spindle normais têm uma taxa de transferência de leitura/gravação relativamente baixa, portanto, o tempo geral de execução pode ser maior do que o da opção de cache MEMORY_ONLY. Para resolver esse problema, podemos aproveitar efetivamente os SSDs, o que pode reduzir potencialmente o tempo geral de conclusão do trabalho em comparação com a abordagem normal baseada em HDD.

A opção DISK_ONLY armazena RDDs apenas em dispositivos de armazenamento não voláteis, como HDDs ou SSDs, ou seja, não na memória principal. Um cluster que não possui quantidade suficiente de memória disponível pode obter um bom desempenho com esta opção. Nesse caso, como o RDD é armazenado apenas na mídia de disco, o espaço aleatório pode ser estendido em vez de usar o espaço de armazenamento da memória. Como resultado, ao executar um aplicativo como o PageRank, que gera uma quantidade relativamente grande de dados aleatórios, podemos observar um desempenho melhor do que no caso SOMENTE MEMÓRIA_.

A opção OFF{0}}HEAP permite que o Spark use espaço fora do heap, que está fora do gerenciamento do coletor de lixo Java. Portanto, se usarmos espaço fora do heap, teremos que lidar com operações complicadas de memória, como alocação/desalocação e serialização/desserialização. Portanto, para fins práticos, não usamos a configuração OFF_HEAP.

3.4. Metodologia de Otimização

Conforme discutimos nas Seções 3.2 e 3.3, nossos métodos de otimização incluem (1) a configuração do heap Spark JVM e (2) as opções experimentais da política de cache RDD como segue:

1. Configuração de heap JVM do Spark: investigamos os efeitos da alteração das taxas de fração de capacidade do embaralhamento e dos espaços de armazenamento. A proporção de embaralhamento e espaço de armazenamento é 60%:30%, 50%:40% e 20%:60%, respectivamente. A proporção de embaralhamento e armazenamento "20%:60%" é o valor padrão na configuração do Spark. Escolhemos "60%:30%" para contrastar o resultado com espaço de shuffle suficiente e configuramos "50%:40%" para mostrar o desempenho de forma equilibrada.

2. Política de cache RDD: Também examinamos os efeitos de diferentes políticas de cache RDD. Comparamos o desempenho de diversas políticas, como OFF_HEAP, MEMORY_ONLY, MEMORY_AND_DISK e DISK{5}}ONLY, onde DISK denota o SSD neste experimento.

A Tabela 3 mostra um total de 12 configurações experimentais diferentes com base nas políticas de cache RDD e nas taxas de fração de capacidade do Spark JVM. Nas configurações experimentais rotuladas com "_1" (por exemplo, "N_1"), definimos 60% do heap Spark JVM para embaralhamento e 30% para espaços de armazenamento. Com aqueles rotulados como "_2", definimos 50% do heap Spark JVM para embaralhamento e 40% para armazenamento. Finalmente, para aqueles rotulados com "_3", definimos 20% do heap Spark JVM para embaralhamento e 60% para armazenamento, como pode ser visto nas colunas "Opção", "Embaralhamento" e "Armazenamento" na Tabela 3. Observe que o tamanho máximo de memória do executor do nosso cluster de teste é 2,7 GB, ou seja, cada nó de trabalho tem 2,7 GB como tamanho de heap JVM do Spark.

Em termos da política de cache RDD, a opção "N" não é armazenar em cache o RDD, a opção "M" é armazenar em cache o RDD apenas na memória, a opção "M&S" é armazenar em cache o RDD na memória e no SSD juntos, e, finalmente, a opção "S" serve para armazenar em cache o RDD apenas no SSD.

Através de nossos experimentos, propomos estratégias de otimização que podem alcançar o melhor desempenho do cluster que possui quantidades de memória insuficientes, ajustando cuidadosamente a configuração de heap JVM do Spark e empregando uma política de cache RDD eficaz, como veremos na Seção 4.

4. Resultados Experimentais e Análise

4.1. Experimentos de PageRank de 500 MB

4.1.1. Resultados com a alteração das configurações de heap da JVM

A Figura 3 mostra os resultados experimentais de cada estágio da carga de trabalho do PageRank alterando os tamanhos de heap da JVM. No estágio Distinto, o Spark lê os dados de entrada e distingue a URL e os links. Como podemos ver nos resultados do estágio Distinct0, o tempo geral de execução diminui alterando os tamanhos de heap da JVM das opções _1 e _2 para _3, principalmente devido para a coleta de lixo (GC). Por exemplo, o tempo de GC leva 25 s, 24 s e 16 s em M&S_1, M&S_2 e M&S{{10}}, respectivamente. Portanto, no estágio Distinct0, à medida que aumentamos a quantidade de espaço de armazenamento, podemos melhorar o desempenho geral reduzindo o tempo de GC. Por outro lado, no estágio Distinct1, o tempo geral de execução aumenta à medida que alteramos as opções de _1 e _2 para _3. Isto é principalmente por causa do derramamento aleatório. Quando verificamos a IU da web do Spark, os dados aleatórios foram derramados no disco devido à falta de espaço na memória aleatória. Por exemplo, os tamanhos dos dados de dispersão aleatória no disco em M&S_1, M&S_2 e M&S_3 são 0, 220 MB e 376 MB, respectivamente. Quando ocorre o derramamento de embaralhamento, as sobrecargas da CPU para espalhar os dados no disco aumentam porque os dados precisam ser serializados.

Após os estágios Distintos, existem estágios iterativos de flatMap para obter classificações. Os estágios FlatMap geram muitos dados aleatórios, o que pode fazer com que nosso cluster não tenha o espaço de memória aleatório necessário. Portanto, à medida que a quantidade disponível de espaço de embaralhamento diminui (na ordem das opções _1, _2 e _3), mais desperdício de embaralhamento pode ocorrer, o que pode afetar potencialmente a execução geral do trabalho tempo (por exemplo, opção M&S flatMap2 estágio _1: 37 s, _2: 40 s, _3: 49 s). No entanto, quando os dados são armazenados em cache apenas na memória (ou seja, M_1, M_2 e M_3), eles mostram outro padrão. A principal razão para esse comportamento é que o agendador Spark agenda as tarefas de forma desigual porque há falta de espaço de armazenamento de memória para armazenar em cache o RDD nas opções _1 e _2. Se um trabalhador não tiver RDDs, ele será excluído do pool de agendamento. Portanto, os outros trabalhadores têm que lidar com tarefas adicionais com sobrecargas de GC que podem afetar todo o tempo de execução do trabalho.

4.1.2. Resultados com a alteração das opções de cache RDD

Em primeiro lugar, os estágios distintos não são afetados pela alteração da política de cache RDD, mas apenas pelo uso da memória. Os estágios afetados pela opção de cache RDD são estágios flatMap, pois durante a fase aleatória, os RDDs armazenados em cache são usados ​​novamente.

Na Figura 4, o gráfico é normalizado pela opção N_1 que não armazena em cache a configuração de memória RDD e _1 para verificar a diferença de desempenho. Ao comparar apenas os gráficos de _1, na ordem de M_1, M&S_1 e S_1, há uma degradação de desempenho de 32% em M{{8 }} e melhorias de desempenho de 30% e 20% com M&S_1 e S_1, respectivamente. Com a opção M_1, o motivo do desempenho relativamente baixo é que os RDDs são armazenados em cache de forma desigual devido à falta de armazenamento, o que resultará em agendamento desigual, como mencionamos anteriormente. Isso significa que o espaço de heap da JVM é insuficiente para embaralhar os dados e salvar os RDDs.

Para resolver esse problema, espalhamos os RDDs para armazenar em cache tanto na memória quanto no SSD, o que pode melhorar o desempenho conforme mostrado com a opção M&S_1. O armazenamento em cache do RDD na memória melhora a velocidade de acesso do RDD, e o armazenamento em cache do RDD no SSD pode evitar o derramamento de embaralhamento, estendendo efetivamente o espaço de embaralhamento disponível na memória. Com a opção S_1 que mostrou uma melhoria de desempenho de 20%, o RDD é armazenado em cache apenas no SSD. O vazamento aleatório é reduzido armazenando em cache o RDD no SSD. No entanto, obteve uma melhoria de desempenho inferior ao M&S_1, onde o RDD é principalmente armazenado em cache na memória e reutilizado a partir da memória.

Na configuração padrão do Spark, que é a opção _3, podemos ver que na ordem de M_3, M&S_3, S_3 e N{{4 }}, o desempenho geral diminui. Na configuração padrão, o armazenamento do heap JVM é suficiente para que o RDD seja armazenado em cache com equilíbrio. Portanto, o desempenho geral depende principalmente do desempenho do dispositivo de memória utilizado. No entanto, ainda podemos ver o melhor desempenho com a opção M&S_1, pois podemos reduzir efetivamente o tempo de GC e o desperdício de embaralhamento armazenando em cache o RDD na memória e no SSD.

4.2. Desempenho de PageRank de 1 GB

Experimentamos a carga de trabalho do PageRank aumentando o tamanho dos dados de 500 MB para 1 GB. A Figura 5 mostra os diferentes comportamentos do sistema em comparação com o PageRank para o conjunto de dados de 500 MB. Podemos ver alguns trabalhos com falha que não conseguiram concluir o trabalho até o estágio take6 (por exemplo, N_1, N_2, M_1, M_2, M _3, M&S_3). Entre esses trabalhos com falha, há aqueles que falharam no estágio flatMap2, que são N_1, N_2 e M_1. O motivo da falha do trabalho é a falta de memória de armazenamento. O GC ocorre quando o RDD é armazenado em cache com memória insuficiente. Devido a essa sobrecarga de GC, o executor Spark recebe uma exceção ExecutorLostFailure.

M_2, M_3 e M&S_3 poderiam prosseguir com o processamento até o estágio flatMap2; entretanto, depois disso, ocorre uma falha. M&S_3 opera de forma semelhante ao M_3 até o estágio flatMap2 porque quando a opção M&S_3 é usada, há memória suficiente para armazenar em cache o RDD. Após o flatMap2, o erro OutOfMemory ocorre devido à falta de espaço de memória aleatória no estágio flatMap3.

4.2.1. Resultados com a alteração da configuração de heap da JVM

O estágio Distinct0 mostra resultados muito semelhantes ao conjunto de dados de 500 MB, e o desempenho geral melhora na ordem das opções _1, _2 e _3. Isso ocorre porque o tempo de GC é reduzido para 78 s, 59 s e 28 s, respectivamente

Por outro lado, na etapa Distinct1 apresentou resultados diferentes para o conjunto de dados de 500 MB. No experimento do conjunto de dados de 500 MB, podemos ver o ganho de desempenho aumentando o espaço aleatório da memória. No entanto, no experimento do conjunto de dados de 1 GB, a memória do executor do nó de trabalho não pode acomodar o grande tamanho dos dados. Portanto, o espaço aleatório da memória torna-se relativamente insuficiente. Por exemplo, as quantidades de dispersão aleatória para as opções _1, _2 e _3 são 575,5 MB, 813,8 MB e 843,4 MB, respectivamente, e o tempo de GC leva 33 s, 10 s e 8 s, respectivamente. Como mencionamos antes, quando ocorre um vazamento aleatório, o RDD precisa ser serializado para que os cálculos da CPU possam aumentar, o que pode resultar na degradação geral do desempenho.

4.2.2. Resultados da alteração da política de cache RDD

Para analisar o tempo de execução alterando a política de cache RDD, como podemos ver na Figura 6, excluímos estágios distintos da Figura 5. Isso ocorre porque não precisamos analisar estágios distintos, uma vez que não há alterações causadas pela alteração da política de cache RDD .

Curiosamente, não há alterações com várias configurações de heap JVM em estágios flatMap, ao contrário do caso do conjunto de dados de 500 MB. A razão para isso é que o derramamento de embaralhamento ocorre em todas as configurações porque não há memória suficiente. O tempo geral de execução alterando a opção de cache RDD aumenta na ordem de M&S, S, N e M. (M&S é a opção mais rápida.) Na opção N, o erro ExecutorLostFailure ocorre porque não há espaço de memória suficiente. Na opção M, quando o RDD é armazenado em cache na memória, a sobrecarga do GC ocorre porque não há espaço de memória suficiente. Mesmo que o RDD esteja armazenado em cache na memória, a tarefa falhará devido ao erro ExecutorLostFailure que ocorre quando o espaço de memória aleatória é insuficiente (OutOfMemory).

Nessas situações de pouca memória disponível, as opções M&S e S podem ser alternativas eficazes. Na opção M&S{{0}}, aumentamos a acessibilidade do RDD armazenando-o em cache usando a memória e o SSD. Como resultado, há uma melhoria de desempenho pelo mesmo motivo que o conjunto de dados de 500 MB. Além disso, há espaço de memória aleatória suficiente devido ao armazenamento em cache do RDD no SSD. Conforme visto na Figura 6, a opção M&S_1 se torna a opção mais rápida neste experimento (M&S_1:0,6, S_1:0,63, T_1 0,64).

4.3. Análise Experimental TC

A Figura 7 mostra os resultados de experimentos de TC (fechamento transitivo) que utilizam os dados de entrada envolvendo 50,000 arestas e 25,000 vértices gerados aleatoriamente. O número da iteração é 10. Através das iterações, o número de tarefas é duplicado a cada iteração e, portanto, o tamanho do RDD aumenta e a quantidade de leitura e gravação aleatória também aumenta. Na última iteração, o número de tarefas passa a ser 4.096. Como há mais estágios de iteração, há um efeito maior no tempo total de execução do trabalho, e o último estágio de iteração é o maior, consistindo em muitas tarefas que podem diminuir o desempenho geral. .

Como podemos ver na Figura 7, o desempenho melhora na ordem de _3, _2 e _1 nas opções M, M&S e S, o que significa que obter um embaralhamento suficiente a memória do heap da JVM é útil. Com a opção M, o desempenho da opção _1 é 18% mais rápido que a opção _3, enquanto, na opção M&S, o desempenho da opção _1 é 3% mais rápido que {{9 }}. Na opção S, o desempenho de _1 é 2% mais rápido que _3.

Quando nos concentramos em alterar a opção de cache RDD, o desempenho da opção S_1 é 42% mais rápido que N_1 e também 31% mais rápido que M_1. A razão para o ganho de desempenho no tempo de execução do trabalho depende do último estágio de iteração. O principal fator que afeta o último estágio de iteração é o tempo de bloqueio da leitura aleatória. O tempo de bloqueio de leitura aleatória ocorre quando o RDD executado no estágio anterior é lido de outro nó de trabalho através da rede devido à falta de memória do executor.

Mesmo que cada tarefa tenha um ganho de desempenho de cerca de 1–2 s através da resolução do tempo bloqueado de leitura aleatória, podemos obter um ganho de desempenho significativo porque, no último estado, o número de tarefas é bastante grande (ou seja, 4.096). Além disso, um dos principais fatores que afetam o tempo de execução do trabalho é a etapa de contagem, que conta quantas arestas a matriz TC possui no último trabalho.

Com a opção N, como não há RDDs armazenados em cache no estágio de contagem, o Spark lê os dados aleatórios executados no estágio anterior, o que leva 60 s. Além disso, na opção M, o RDD não é armazenado em cache na memória devido à falta de memória do executor. Como resultado, também leva 60 s. Porém, nas opções M&S e S, o RDD pode ser armazenado em cache na memória e no SSD, de modo que leva apenas 2 s no estágio de contagem.

4.4. Análise Experimental TeraSort

A Figura 8 mostra os resultados experimentais do benchmark TeraSort que usa um conjunto de dados de 10 GB alterando a configuração de heap JVM e a opção de cache RDD. Este gráfico é normalizado pela opção N_1. Podemos ver que todos os tempos de execução do trabalho são semelhantes; a diferença entre eles é inferior a 5%. Na carga de trabalho do TeraSort não houve melhorias ou degradações de desempenho pela alteração das configurações e opções. No estágio de classificação, ocorrem alguns embaralhamentos na rede. No entanto, os tamanhos de leitura e gravação aleatória são de 25 MB cada, o que é bastante pequeno em comparação com PageRank e TC. Portanto, a configuração de heap da JVM e a opção de cache RDD não afetam o desempenho. Além disso, a carga de trabalho do TeraSort não consiste em trabalhos iterativos como no encerramento transitivo, portanto não há benefício do cache RDD no estágio anterior.

4.5. Análise Experimental de Clustering K-Means

O tempo normalizado de conclusão do trabalho de cluster k-means para o conjunto de dados de 1,5 GB é mostrado na Figura 9. O objetivo do cluster k-means é encontrar os k clusters no conjunto de dados com base na medição de distância (por exemplo, distância euclidiana). Nesta carga de trabalho, o algoritmo reduz o SSE (soma do erro quadrático) [24] iterando o cálculo da distância entre os k pontos centrais e cada ponto de dados. Neste experimento, iteramos esse processo oito vezes. A quantidade de dados a serem embaralhados é mínima porque os dados necessários do estágio anterior são as informações sobre os pontos centrais e SSE em cada estágio. Em nossa carga de trabalho de clustering k-means, a quantidade máxima de dados de leitura/gravação aleatória é de 1,0 MB e a mínima é de 0,8 MB. O derramamento de embaralhamento não ocorre aqui porque o espaço de embaralhamento é suficiente em todas as configurações. Nos experimentos sem opções de cache, não há diferença entre as opções _1, _2 e _3, pois essas configurações não armazenam em cache nenhum RDD e, em todas as três configurações, o embaralhamento o espaço é suficiente.

Ao armazenar em cache os RDDs na memória principal ou na memória e SSD, quanto mais espaço de armazenamento para o RDD, mais o desempenho no tempo de execução do trabalho melhora porque mais RDDs podem ser armazenados em cache no espaço de armazenamento. Ao comparar a opção_somente memória e a opção memória_e_SSD, a opção memória_e_SSD mostrou melhor melhoria de desempenho. Isso ocorre porque, na opção somente memória, o espaço de armazenamento é insuficiente mesmo na opção M_3. Além disso, armazenar em cache os RDDs no SSD resolve essa falta de memória de armazenamento. As opções de memória_e_SSD melhoraram o desempenho em 10%, em média, em comparação com a opção_apenas de memória.

Observe que a carga de trabalho de clustering k-means mostra uma tendência de desempenho oposta ao PageRank e às cargas de trabalho de fechamento transitivo devido à diferença na quantidade de dados embaralhados. Discutiremos isso com mais detalhes na subseção a seguir.

5. Discussão e Resumo

5.1. Discussão

Analisamos os principais fatores de possíveis problemas de degradação de desempenho com base nas características da carga de trabalho e dos estágios de processamento. Nossos extensos resultados experimentais são resumidos em relação à aplicação das técnicas de otimização de desempenho da plataforma Spark para várias cargas de trabalho da seguinte forma:

• A degradação do desempenho pela coleta de lixo Java: na carga de trabalho do PageRank com o conjunto de dados de 500 MB e o conjunto de dados de 1 GB, o GC ocorre quando não há espaço de armazenamento suficiente no heap da JVM para armazenar o RDD. No estágio Distinct0, que lê o arquivo de entrada do HDFS e o armazena em cache no RDD, ocorre o GC. Expandimos o espaço de armazenamento do heap JVM por meio da configuração para resolver esse problema de GC. Podemos melhorar o desempenho para reduzir o GC porque o espaço de armazenamento do heap JVM pode ser expandido. Nas Figuras 3 e 5, com a mesma opção de cache RDD, a configuração _3 apresenta o melhor desempenho no estágio Distinct0. Além disso, no PageRank com conjunto de dados de 1 GB, algumas opções falham no estágio flatMap por falta de memória. A sobrecarga do GC aumenta tanto que o estágio falha ou entra em loop infinito. Assim, construímos o cluster com SSDs para resolver este problema. Ele mostra uma melhoria de desempenho e é bem-sucedido no trabalho que falhou usando apenas memória, como visto na Figura 6, M&S_1 e S_1.

• A degradação do desempenho por derramamento de embaralhamento: na carga de trabalho do PageRank com o conjunto de dados de 500 MB e o conjunto de dados de 1 GB, no estágio flatMap, podemos ver que a opção M&S_1 mostra o melhor desempenho porque tem a menor quantidade de embaralhamento derramamento (Figura 4: M&S_1 é 30% mais rápido que N_1; Figura 6: M&S_1 é 40% mais rápido que N_3). PageRank tem muitas tarefas aleatórias. Assim, quando o espaço de embaralhamento do heap da JVM é insuficiente para embaralhar os dados pela rede, ocorre o derramamento de embaralhamento. Portanto, para reduzir o derramamento de embaralhamento, a expansão do espaço de embaralhamento do heap da JVM torna-se o fator chave para a melhoria do desempenho.

Além disso, podemos melhorar o desempenho armazenando o RDD tanto na memória quanto no SSD. Isso pode fazer com que o executor expanda a memória aleatória do heap da JVM para reduzir o desperdício de embaralhamento. Se houver mais iterações, o desempenho do estágio flatMap seria o ponto chave da melhoria de desempenho. No experimento do conjunto de dados de 1 GB, o tempo de execução do trabalho de S_3 é a melhor opção, porque os RDDs são armazenados em cache apenas no SSD e há memória heap suficiente nos executores. Assim, na opção S_3, os estágios Distintos são mais rápidos que qualquer outra opção. Entretanto, se o número de iterações aumentar, o estágio flatMap afetará o tempo de execução do trabalho. Assim, a opção M&S_1 pode alcançar ótimo desempenho neste caso. Por meio dessas análises, podemos identificar que o embaralhamento tem um efeito fundamental no tempo de conclusão do trabalho. Portanto, temos que expandir a memória aleatória do heap JVM e armazenar em cache o RDD na memória e no SSD para obter espaço de memória aleatória suficiente para evitar o derramamento de shuffle.

• A degradação do desempenho por tempo de bloqueio de leitura aleatória: há tempo de bloqueio de leitura aleatória na carga de trabalho de TC. Ocorre quando há muitas tarefas no estágio e cada tarefa precisa ler o RDD anterior pela rede. Como resultado do experimento TC (Figura 7), a opção M&S é mais rápida que a opção M. Na mesma opção de cache RDD, expandir o espaço aleatório do heap JVM é mais rápido do que expandir o espaço de armazenamento. A razão para melhorar o desempenho é que, ao expandir o espaço de embaralhamento do heap da JVM, o tempo de bloqueio de leitura aleatória diminui em cada tarefa.

5.2. Resumo: Qual é a melhor maneira?

Nos resultados experimentais abrangentes, não existe uma única configuração melhor para impulsionar todas as cargas de trabalho, uma vez que cada uma destas cargas de trabalho tem características diferentes, mesmo durante a vida útil do trabalho. No entanto, ainda podemos propor como otimizar as configurações de uma plataforma de computação distribuída na memória, considerando a variedade de cargas de trabalho alvo da seguinte forma:

• Configuração de heap JVM do Spark — área aleatória versus área de armazenamento: de acordo com os resultados experimentais de quatro cargas de trabalho diferentes, podemos observar as diferenças de desempenho dependendo das características da carga de trabalho. Por exemplo, o PageRank é um exemplo típico de ter uma grande quantidade de dados aleatórios, portanto, alocar mais memória para a parte aleatória melhora o desempenho geral. No entanto, no caso do cluster k-means, quanto mais alocamos para memória de armazenamento, em oposição à memória aleatória, menos tempo de execução será necessário. Portanto, se pudermos ajustar dinamicamente a porcentagem de alocação de memória da JVM de acordo com as características da carga de trabalho, poderemos otimizar o tempo total de execução. O Hadoop YARN [25] nos permite atribuir jobs a diferentes tipos de clusters (configurações) para que possamos aplicar essa ideia a um cluster Hadoop de grande porte para atender às características de memória para vários tipos de jobs.

• Política de cache RDD – memória versus SSD: Na maioria dos casos, o cache de memória apoiado por SSD apresenta o melhor desempenho, a menos que todos os RDDs caibam na memória principal real. Portanto, a política de cache de memória assistida por SSD pode ser uma escolha viável para cargas de trabalho desafiadoras que exigem quantidades substanciais de memória principal que não podem ser atendidas por nenhum nó único em um cluster.

6. conclusões

Neste artigo, investigamos os principais fatores para a degradação do desempenho do sistema Spark rodando em um cluster de computação baseado em servidor commodity com memórias principais disponíveis insuficientes. Após experimentação e análise, apresentamos alternativas que podem melhorar o desempenho geral.

A coleta de lixo Java ocorre quando o espaço de armazenamento do heap JVM é insuficiente devido à falta de memória física. Java GC faz com que as tarefas aguardem a coleta de lixo para que o tempo geral de conclusão do trabalho aumente. O derramamento de embaralhamento ocorre quando o espaço de embaralhamento do heap da JVM é insuficiente durante a fase de embaralhamento. O derramamento de embaralhamento aumenta a sobrecarga da CPU para executar a serialização para derramar dados de embaralhamento intermediários no disco devido à falta de espaço de embaralhamento. No experimento de carga de trabalho TC, o tempo de bloqueio de leitura aleatória faz com que a tarefa espere pela leitura dos dados aleatórios pela rede devido à falta de espaço para embaralhamento. Todos esses fatores podem aumentar potencialmente o tempo geral de conclusão do trabalho, o que pode afetar seriamente o desempenho do sistema Spark.

Para resolver esses problemas, construímos um cluster com um SSD e armazenamos em cache o RDD na memória e no SSD separadamente, utilizando o SSD para complementar o espaço de armazenamento da memória. Além disso, ajustamos a configuração de heap da JVM para expandir o espaço aleatório. Como resultado, poderíamos alcançar uma melhoria de desempenho de 30% para a carga de trabalho do PageRank e uma melhoria de desempenho de 42% para a carga de trabalho do TC. Identificamos que o vazamento de embaralhamento pode ser um fator-chave de degradação de desempenho e mostramos, por meio de experimentação, que em cargas de trabalho que consistem em diversas iterações e embaralhamento, a expansão do espaço de embaralhamento pode proporcionar ganhos significativos de desempenho. Além disso, descobrimos que diferentes padrões de uso de memória de trabalhos podem afetar o tempo total de execução dependendo da porcentagem de alocação de memória de armazenamento/embaralhamento na JVM. De acordo com a análise de desempenho do clustering PageRank e k-means, a alocação de memória na JVM bem ajustada às características da carga de trabalho pode melhorar significativamente o tempo de conclusão do trabalho.

Integrar essas descobertas na plataforma Spark seria um dos nossos trabalhos futuros. Por exemplo, se as cargas de trabalho puderem ser caracterizadas em termos de quantidades de dados embaralhados, uma configuração otimizada poderá ser aplicada automaticamente para acelerar o processamento das cargas de trabalho de destino. Portanto, em configurações de servidor heterogêneas, o desenvolvimento de um sistema de agendamento com reconhecimento de uso de memória de carga de trabalho pode melhorar o desempenho geral de um cluster baseado em Spark.

Contribuições do autor:

Conceituação, JL (Jaehwan Lee); metodologia, JL (Jaehwan Lee) e JC; software, JC e JL (Jaehyun Lee); validação, JC, JL (Jaehyun Lee) e JL (Jaehwan Lee); investigação, JL (Jaehwan Lee) e J.-SK; recursos, JL (Jaehwan Lee) e J.-SK; curadoria de dados, JC e JL (Jaehyun Lee); redação – preparação do rascunho original, JC e JL (Jaehyun Lee); redação – revisão e edição, JL (Jaehwan Lee) e J.-SK; visualização, JL (Jaehyun Lee); supervisão, JL (Jaehwan Lee) e J.-SK; administração do projeto, JL (Jaehwan Lee) e J.-SK; aquisição de financiamento, JL (Jaehwan Lee). Todos os autores leram e concordaram com a versão publicada do manuscrito.

Financiamento:

Esta pesquisa foi apoiada pelo Programa de Pesquisa Científica Básica (NRF-2020R1F1A1072696) por meio da Fundação Nacional de Pesquisa da Coreia (NRF), financiada pelo Ministério da Ciência e TIC, programa GRRC da província de Gyeonggi (No. GRRC-KAU{ {5}}B01, "Estudo sobre a plataforma de convergência de vídeo e espaço para serviços 360VR") e programa de suporte do ITRC (Centro de Pesquisa de Tecnologia da Informação) (IITP-2021-2018-0-01423).

Declaração do Conselho de Revisão Institucional:

Não aplicável.

Declaração de consentimento informado:

Não aplicável.

Declaração de disponibilidade de dados:

Disponível mediante solicitação.

Conflitos de interesse:

Os autores declaram não haver conflito de interesses.

Referências

1. Dean, J.; Ghemawat, S. MapReduce: Processamento de dados simplificado em grandes clusters. Comum. ACM 2008, 51, 107–113. [RefCruz]

2. O Projeto Apache Hadoop: Software de Código Aberto para Computação Distribuída Confiável, Escalável. Disponível online: https: //hadoop.apache.org/ (acessado em 10 de setembro de 2021).

3. Shvachko, K.; Kuang, H.; Rádio, S.; Chansler, R. O sistema de arquivos distribuído Hadoop. Em Anais do 26º simpósio IEEE de 2010 sobre sistemas e tecnologias de armazenamento em massa (MSST), Incline Village, NV, EUA, 3–7 de maio de 2010; páginas 1–10.

4. Zaharia, M.; Chowdhury, M.; Franklin, MJ; Shenker, S.; Stoica, I. Spark: Computação em cluster com conjuntos de trabalho. HotCloud 2010, 10, 95.

5. Ousterhout, K.; Rasti, R.; Ratnasamy, S.; Shenker, S.; Chun, BG Entendendo o desempenho em estruturas de análise de dados. Em Anais do 12º Simpósio USENIX sobre Design e Implementação de Sistemas em Rede (NSDI), Oakland, CA, EUA, 4–6 de maio de 2015; páginas 293–307.

6.Xing, W.; Ghorbani, A. Algoritmo PageRank ponderado. Em Proceedings of the IEEE Second Annual Conference on Communication Networks and Services Research, Fredericton, NB, Canadá, 21 de maio de 2004; págs. 305–314.

7.Chakradhar, ST; Agrawal, VD; Rothweiler, SG Um algoritmo de fechamento transitivo para geração de testes. IEEE Trans. Comput.-Aided Des. Integr. Sistema de Circuitos 1993, 12, 1015–1028. [RefCruz]

8. O'Malley, O. Classificação de terabytes no Apache Hadoop. Yahoo. Maio de 2008. pp. Disponível online: http://sortbenchmark.org/ YahooHadoop.pdf (acessado em 10 de setembro de 2021).

9. Agrupamento K-Means. Disponível on-line: https://en.wikipedia.org/wiki/K-means_clustering (acessado em 10 de setembro de 2021).

10. Zaharia, M.; Chowdhury, M.; Das, T.; David, A.; Mãe, J.; McCauly, M.; Franklin, MJ; Shenker, S.; Stoica, I. Conjuntos de dados distribuídos resilientes: uma abstração tolerante a falhas para computação em cluster na memória. Em Anais do 9º Simpósio USENIX sobre Design e Implementação de Sistemas em Rede (NSDI), San Jose, CA, EUA, 25–27 de abril de 2012; págs. 15–28.

11.Davidson, A.; Ou A. Otimizando o desempenho do Shuffle no Spark; Relatório técnico; Berkeley-Departamento de Engenharia Elétrica e Ciências da Computação, Universidade da Califórnia: Berkeley, CA, EUA, 2013.

12. Nicolae, B.; Costa, CHA; Misale, C.; Katrinis, K.; Park, Y. Aproveitando E/S adaptativa para otimizar padrões coletivos de embaralhamento de dados para análise de Big Data. IEEE Trans. Distribuição Paralela. Sist. 2017, 28, 1663–1674. [RefCruz]

13.Zhang, H.; Cho, B.; Seyfe, E.; Ching, A.; Freedman, MJ Riffle: Serviço Shuffle otimizado para análise de dados em grande escala. Nos Anais da Décima Terceira Conferência EuroSys; EuroSys '18; Association for Computing Machinery: Nova York, NY, EUA, 2018. [CrossRef]

For more information:1950477648nn@gmail.com