+
+
+
+
+Lista Programação Concorrente e distribuída
+Resolução feita por Samuel Cavalcanti
+
+
+
+
+Copyright © 2022 Samuel Cavalcanti
+ +2. Chapter 1
2.1 Capítulo 1
+Capítulo 1: 1-6, 9; (7 questões)
+-
+
-
+
Devise formulas for the functions that calculate my_first_i and my_last_i in the global sum example. Remember that each core should be assigned roughly the same number of elements of computations in the loop. Hint: First consider the case when n is evenly divisible by p
+ +
+ -
+
We’ve implicitly assumed that each call to Compute_next_value requires roughly the same amount of work as the other calls. How would you change your answer to the preceding question if call i = k requires k + 1 times as much work as the call with i = 0? So if the first call (i = 0) requires 2 milliseconds, the second call (i = 1) requires 4, the third (i = 2) requires 6, and so on.
+ +
+ -
+
Try to write pseudo-code for the tree-structured global sum illustrated in +Figure 1.1. Assume the number of cores is a power of two (1, 2, 4, 8, . . . ).
+ +
+ -
+
As an alternative to the approach outlined in the preceding problem we can use C’s bitwise operators to implement the tree-structured global sum. In order to see how this works, it helps to write down the binary (base 2) representation of each of the core ranks, and note the pairings during each stage
+ +
+ -
+
What happens if your pseudo-code in Exercise 1.3 or Exercise 1.4 is run when the number of cores is not a power of two (e.g., 3, 5, 6, 7) ? Can you modify the +pseudo-code so that it will work correctly regardless of the number of cores ?
+ +
+ -
+
Derive formulas for the number of receives and additions that core 0 carries out using:
+ +
+ a. the original pseudo-code for a global sum
+ b. the tree-structured global sum.
+Make a table showing the numbers of receives and additions carried out by core +0 when the two sums are used with 2, 4, 8, . . . , 1024 cores.
+
+
+ -
+
Write an essay describing a research problem in your major that would benefit from the use of parallel computing. Provide a rough outline of how parallelism would be used. Would you use task- or data-parallelism ?
+ +
+
2.2 Question 1
2.2.1 Questão 1
+Devise formulas for the functions that calculate my_first_i and my_last_i in the global sum example. Remember that each core should be assigned roughly the same number of elements of computations in the loop. Hint: First consider the case when n is evenly divisible by p
+struct range
+{
+ int first;
+ int last;
+};
+struct range new_range(int thread_index, int p, int n)
+{
+ struct range r;
+
+ int division = n / p;
+ int rest = n % p;
+
+ if (rest == 0)
+ {
+ r.first = thread_index * division;
+ r.last = (thread_index + 1) * division;
+ }
+ else
+ {
+ r.first = thread_index == 0 ? 0 : thread_index * division + rest;
+ r.last = (thread_index + 1) * division + rest;
+ }
+
+ if (r.last > n)
+ r.last = n;
+
+ return r;
+}
+
+struct range new_range_2(int thread_index, int p, int n)
+{
+ struct range r;
+
+ int division = n / p;
+ int rest = n % p;
+
+ if (thread_index < rest)
+ {
+ r.first = thread_index * (division + 1);
+ r.last = r.first + division + 1;
+ }
+ else
+ {
+ r.first = thread_index * division + rest;
+ r.last = r.first + division;
+ }
+
+ return r;
+}
+First 0 Last 20 m Last - First: 20
+First 20 Last 40 m Last - First: 20
+First 40 Last 60 m Last - First: 20
+First 60 Last 80 m Last - First: 20
+First 80 Last 100 m Last - First: 20
+First 0 Last 25 m Last - First: 25
+First 25 Last 50 m Last - First: 25
+First 50 Last 75 m Last - First: 25
+First 75 Last 99 m Last - First: 24
+First 99 Last 123 m Last - First: 24
+Test question 1 success
+OLD new range
+First 0 Last 27 m Last - First: 27
+First 27 Last 51 m Last - First: 24
+First 51 Last 75 m Last - First: 24
+First 75 Last 99 m Last - First: 24
+First 99 Last 123 m Last - First: 24
+2.3 Question 2
2.3.1 Questão 2
+We’ve implicitly assumed that each call to Compute_next_value requires roughly the same amount of work as the other calls. How would you change your answer to the preceding question if call i = k requires k + 1 times as much work as the call with i = 0? So if the first call (i = 0) requires 2 milliseconds, the second call (i = 1) requires 4, the third (i = 2) requires 6, and so on.
+Somatório de Gauss
+
Exemplo, Supondo que k = 10, temos o seguinte vetor de índice:
+indices = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+utilizando a lógica da somatório de gauss e organizando os indicies temos um array normalizado:
+normalized_array = [ [0, 9], [1, 8], [2, 7], [3, 6], [4, 5] ]
+onde o custo de cada índice do normalized_array é igual, por tanto
+podemos usar o algoritmo da questão 1 aplicado ao normalized_array
+resultando:
| Thread | +normalized_array | +
|---|---|
| 1 | +0,1 | +
| 2 | +2,3 | +
| 3 | +4 | +
| Thread | +Compute_next_value | +cost | +
|---|---|---|
| 1 | +0, 9,1, 8 | +44 | +
| 2 | +2, 7,3, 6 | +44 | +
| 3 | +4, 5 | +22 | +
2.4 Question 3
2.4.1 Questão 3
+Try to write pseudo-code for the tree-structured global sum illustrated in +Figure 1.1. Assume the number of cores is a power of two (1, 2, 4, 8, . . . ).
+Para criar a árvore, foi considerado que o vetor principal já foi igualmente espaçado entre as p threads, usando o algoritmo da questão 1.
+Representação de um Nó
+Neste caso foi representado o nó, como uma estrutura que possui um vetor de vizinhos e outro ponteiro para um vetor de inteiros, na prática, +o ponteiro para um vetor de inteiros, seria usando o design pattern chamado Future, ou um Option\<Future>.
+Também foi criado dois construtores um construtor que representa, +a inicialização do Nó por meio dos seus vizinhos a esquerda e direita, +usando na criação de nós intermediários da árvore, e a inicialização +do Nó por meio do seu dado, os nós inicializados por meio dos dados +abstrai os núcleos ou as threads que estão sendo usadas para +executar o algoritmo de alto custo computacional.
+class Node
+{
+public:
+ std::vector<Node *> neighborhoods;
+ std::vector<int> *data;
+ Node(Node *left, Node *right)
+ {
+ this->neighborhoods.push_back(left);
+ this->neighborhoods.push_back(right);
+ this->data = nullptr;
+ }
+ Node(std::vector<int> *data)
+ {
+ this->data = data;
+ }
+ ~Node()
+ {
+ delete this->data;
+ }
+};
+Função que cria a Árvore
+Para criar a Árvore foi feita uma função recursiva que +a partir do nível mais baixo da árvore cria a raiz, ou seja, +a partir um vetor com p Nós ,a função vai sendo chamada recursivamente, +onde a cada chamada vai-se criando um nível acima da árvore, até +que se atinja a raiz, onde a cada nível o número de nós é dividido +por 2. Caso o número de nós inicial não for divisível pro 2, o algoritmo não funciona
+std::vector<Node *> create_tree_from_core_nodes(std::vector<Node *> nodes)
+{
+ auto size = nodes.size();
+
+ if (size / 2 == 1)
+ {
+ auto left = nodes[0];
+ auto right = nodes[1];
+ receive_value(left, right); // Left receive value from right
+ return {left};
+ }
+
+ auto new_nodes = std::vector<Node *>{};
+
+ for (auto i = 0; i < size; i += 2)
+ {
+ auto left = nodes[i];
+ auto right = nodes[i + 1];
+ receive_value(left, right); // Left receive value from right
+ new_nodes.push_back(left);
+ }
+
+ return create_tree_from_core_nodes(new_nodes);
+}
+
+Node *create_new_tree(std::vector<Node *> nodes)
+{
+ return create_tree_from_core_nodes(nodes)[0];
+}
+Após criar a árvore basta percorrer-lá recursivamente, lembrando que na prática +compute_data, seria um join, ou um await, de uma thread.
+int compute_data(std::vector<int> *data)
+{
+ auto total = 0;
+ auto size = data->size();
+ for (auto i = 0; i < size; i++)
+ {
+ total += data->at(i);
+ }
+
+ return total;
+}
+int compute_node(Node &node)
+{
+
+ int result_data = node.data == nullptr ? 0 : compute_data(node.data);
+
+ for (auto neighborhood : node.neighborhoods)
+ result_data += compute_node(*neighborhood);
+
+ return result_data;
+}
+2.5 Question 4
2.5.1 Questão 4
+As an alternative to the approach outlined in the preceding problem we can use C’s bitwise operators to implement the tree-structured global sum. In order to see how this works, it helps to write down the binary (base 2) representation of each of the core ranks, and note the pairings during each stage
+Semelhante ao questão 3 sendo a diferença utilizar o bitwise << para dividir +o tamanho atual da função recursiva:
+std::vector<Node *> create_new_tree_bitwise(std::vector<Node *> nodes)
+{
+
+ auto size = nodes.size();
+
+ if (size >> 1 == 1) // alteração.
+ {
+ auto left = nodes[0];
+ auto right = nodes[1];
+ receive_value(left, right);
+ return {left};
+ }
+
+ auto new_nodes = std::vector<Node *>{};
+
+ for (auto i = 0; i < size; i += 2)
+ {
+ auto left = nodes[i];
+ auto right = nodes[i + 1];
+ receive_value(left, right); // Left receive value from right
+ new_nodes.push_back(left);
+ }
+
+ return create_new_tree_bitwise(new_nodes);
+}
+2.6 Question 5
2.6.1 Questão 5
+What happens if your pseudo-code in Exercise 1.3 or Exercise 1.4 is run when the number of cores is not a power of two (e.g., 3, 5, 6, 7) ? Can you modify the +pseudo-code so that it will work correctly regardless of the number of cores ?
+Entendendo o que acontece quanto os número de núcleos não é da potencia de 2
+Se por exemplo, o número de cores, ou Nós for 3 por exemplo, existirá nós que serão "esquecidos" no algoritmo, por tanto +o algoritmo não funcionará corretamente. +
auto size = nodes.size();// size = 3
+
+if (size >> 1 == 1) // alteração.
+{
+ auto left = nodes[0];
+ auto right = nodes[1];
+ // node[2] foi esquecido
+ receive_value(left, right); // Left receive value from right
+ return {left};
+}
+ou se o por exemplo o número de nós for 7, a última iteração do laço for, os indices i, i+1, serão respectivamente +6 e 7, ou seja será acessado um endereço inválido 7, uma vez que os indices vão de 0 até 6. +
auto new_nodes = std::vector<Node *>{};
+
+ for (auto i = 0; i < size; i += 2)
+ {
+ auto left = nodes[i];
+ auto right = nodes[i + 1];
+ receive_value(left, right); // Left receive value from right
+ new_nodes.push_back(left);
+ }
+
+ return create_new_tree_bitwise(new_nodes);
+Para isso foram feitas as seguintes modificações:
+ - adicionado condicionamento para verificar se o tamanho é igual 3
+ - alterado o bitwise para apenas um comparador size ==2
+ - verificado se o tamanho dos nós é par, caso nãos seja adicionado uma logica extra.
std::vector<Node *> create_new_tree_bitwise(std::vector<Node *> nodes)
+{
+
+ auto size = nodes.size();
+
+ if (size == 2)
+ {
+ auto left = nodes[0];
+ auto right = nodes[1];
+ receive_value(left, right);
+ return {left}; // Construtor C++ Moderno.
+ }
+ if (size == 3)
+ {
+ auto left = nodes[0];
+ auto middle = nodes[1];
+ auto right = nodes[2];
+ receive_value(left, middle); // Left receive value from middle
+ receive_value(left, right); // Left receive value from right
+ return {left}; // Construtor C++ Moderno.
+ }
+
+ auto new_nodes = std::vector<Node *>{};
+
+ if (size % 2 != 0) // lógica extra.
+ {
+ size = size - 1;
+ new_nodes.push_back(nodes[size]);
+ }
+
+ for (auto i = 0; i < size; i += 2)
+ {
+ auto left = nodes[i];
+ auto right = nodes[i + 1];
+ receive_value(left, right); // Left receive value from right
+ new_nodes.push_back(left);
+ }
+
+ return create_new_tree_bitwise(new_nodes);
+}
+Explicando a lógica extra
+Além de adicionar uma verificação para saber se o tamanho é par, +foi adicionado dois comandos extras, o primeiro é alterar o tamanho (size), para um valor menor, uma vez que estávamos acessando um índice +maior que o permitido. Segundo foi adicionar o nó que não será percorrido +pelo laço para o vetor new_nodes que será a entrada da próxima função recursiva
+ if (size % 2 != 0) // verificação se é par.
+ {
+ size = size - 1; //1
+ new_nodes.push_back(nodes[size]); // 2
+ }
+Explicando o novo caso base
+Percebemos que além do 2/2 == 1, a divisão inteira de 3/2 também é igual 1. Por tanto além do caso base de quando o tamanho do vetor de nós ser igual a 2, temos que tratar também quando o número de nós ser igual a 3.
+ if (size == 2)
+ {
+ auto left = nodes[0];
+ auto right = nodes[1];
+ receive_value(left, right);
+ return {left}; // Construtor C++ Moderno.
+ }
+ if (size == 3)
+ {
+ auto left = nodes[0];
+ auto middle = nodes[1];
+ auto right = nodes[2];
+ receive_value(left, middle); // Left receive value from middle
+ receive_value(left, right); // Left receive value from right
+ return {left}; // Construtor C++ Moderno.
+ }
+Como no exemplo abaixo, onde a segunda iteração do algoritmo o número de nós é 3.
+
2.7 Question 6
2.7.1 Questão 6
+Derive formulas for the number of receives and additions that core 0 carries out using:
+ a. the original pseudo-code for a global sum
+ b. the tree-structured global sum.
+Make a table showing the numbers of receives and additions carried out by core
+0 when the two sums are used with 2, 4, 8, . . . , 1024 cores.
Tabela mostrando o número de receives, ou joins que o core 0 terá
+-
+
- A coluna Cores representa o número de núcleos, que estão em potência de 2. +
- A coluna Naive, é o número de receives que o core 0 terá caso utilizado +a abordagem ingenua do core 0 esperar todos os outros e somar todo de uma vez. +
- A coluna Tree é o número de receives que o core 0 terá utilizando a abordagem em árvore. +
| Cores | +Naive | +Tree | +
|---|---|---|
| 2 | +1 | +1 | +
| 4 | +3 | +2 | +
| 8 | +7 | +3 | +
| 16 | +15 | +4 | +
| 32 | +31 | +5 | +
| 64 | +63 | +6 | +
| 128 | +127 | +7 | +
| 256 | +255 | +8 | +
| 512 | +512 | +9 | +
| 1024 | +1023 | +10 | +
Podemos observar claramente que a abordagem ingênua segue a formula,
+p -1 e quando usamos a árvore, percebemos que a cada 2 núcleos,
+o número de ligações amentar em 1, ou seja, log(p) de base 2.
+Podemos ver o número de ligações crescendo linearmente com cada dois núcleos na imagem abaixo
+
2.8 Question 9
2.8.1 Questão 9
+Write an essay describing a research problem in your major that would benefit from the use of parallel computing. Provide a rough outline of how parallelism would be used. Would you use task- or data-parallelism ?
+TinyML in Context of web browser
+Em contexto de aplicações web, especificamente a camada front-end, vem se popularizando frameworks que utilizam o WebAssembly (Wasm). O WebAssembly é um novo tipo de código que pode ser executado em browsers modernos — se trata de uma linguagem de baixo nível como assembly, com um formato binário compacto que executa com performance quase nativa e que fornece um novo alvo de compilação para linguagens como C/C++, para que possam ser executadas na web developer.mozilla.org. Através do Wasm é possível +implementar algoritmos de Tiny machine learning (TinyML) para classificação, analise de dados sem a necessidade de comunicação com backend. TinyML é amplamente definido como uma rápida e crescente área de aprendizado de máquina e suas aplicações que inclui hardware, algoritmos e software capazes de performar analise de dados em dispositivos de baixo consumo de energia, tipicamente em milliwatts, assim habilitado variados casos de uso e dispositivos que possuem bateria. Em um navegador, ou durante a navegação o usuário está a +todo momento produzindo dados que muitas vezes estão sendo enviados +de forma bruta ou quase bruta para a camada de aplicação ou back-end, onde nela é gasto processamento e memória para a primeira etapa de classificação ou analise dos dados. Uma vez analisado desempenho de técnicas e algoritmos de TinyML utilizando WebAssembly, pode ser possível transferir a responsabilidade da analise dos dados para o front-end. Em contexto de navegador quase tudo é paralelo ou distribuído, +uma aba ou tab em inglês é um processo diferente. Criar um uma extensão, que faça aquisição e analise dos dados de diferentes abas, seria criar um sistema que se comunica com diferentes processos por meio de mensagens e o algoritmo de aprendizado pode fazer uso de idealmente uma ou duas threads para realizar a analise rapidamente. Por tanto é um +sistema que é task-and-data parallel.
+
