PPD - Trabalho Borg
De Aulas
Links relacionados: Programação Paralela e Distribuída
Descrição
Utilizando o sistema abaixo (Borg), desenvolver um novo problema a ser resolvido de forma distribuída, implementando-o em 'Borg.java e acrescente a nova funcionalidade em Borgd.java.
Borg
Borg (apresentado a baixo) é um sistema simples em java, a titulo de aprendizado, para calcular o fatorial de um número. O sistema divide o problema em subproblemas e os distribui em outras maquinas. Cada máquina resolve parte do problema e devolve ao servidor. O sistema é dividido em 3 classes:
Borg.java
Aplicacao que divide o problema em partes, cria quantos processos forem possíveis, conforme o numero de servidores disponíveis.
Na definição dos servidores e portas para conexões podem existir dois servidores em uma mesma maquina. Nesse caso, é necessário especificar portas diferentes para cada um deles.
Neste exercício é apresentado um exemplo de criação de três processos para três servidores. Observa-se que os servidores precisam estar rodando nas máquinas especificadas caso não seja localhost.
1/**
2 * Copyright 2001-2050 Saulo Popov Zambiasi. All rights reserved. Last modified:
3 * 2013/05/21
4 *
5 * Borg
6 *
7 * Divide tarefa em partes, criando um processo para cada servidore requisitado.
8 *
9 * Neste exercicio eh apresentado um exemplo de criacao de tres processos para
10 * três servidores. Quando houver dois servidores rodando na mesma maquina, eh
11 * necessario configurar portas diferentes para cada servidor.
12 *
13 * Exemplo de servidores e portas:
14 *
15 * String[] server = { "localhost", "192.168.1.1", "192.168.1.2" }
16 *
17 * int[] port = { 4400, 4401 , 4400 }
18 */
19
20import java.math.BigDecimal;
21
22public class Borg {
23 static public void main(String[] arguments) {
24 String[] server = { "localhost", "localhost", "localhost" };
25 int[] port = { 4400, 4401, 4402 };
26 int number = 0;
27
28 // Pega o numero passado como parametro para o calculo do fatorial
29 if (arguments.length == 1) {
30 number = Integer.parseInt(arguments[0]);
31 } else {
32 System.out.println("Use: java Borg number");
33 return;
34 }
35 // Divide o numero em partes, cada parte para cada processo
36 int size = (int) (number / server.length);
37 int counter = 1;
38
39 // Criacao dos processos para controlar a comunicacao com os daemons
40 BorgProcess[] ap = new BorgProcess[server.length];
41 for (int i = 0; i < server.length; i++) {
42 try {
43 int start = counter;
44 int end = counter + size;
45 if (end > number)
46 end = number;
47 counter = end + 1;
48 String message = "fatorial " + start + " " + end;
49 // Cria o processo e envia a mensagem para o mesmo
50 ap[i] = new BorgProcess(server[i], port[i], message);
51 } catch (Exception e) {
52 System.out.println("ERRO: " + e.toString());
53 }
54 }
55
56 // Espera o retorno de cada processo e multiplica os resultados.
57 BigDecimal result = new BigDecimal("1");
58 boolean terminou = false;
59 while (!terminou) {
60 terminou = true;
61 for (int i = 0; i < server.length; i++) {
62 if (!ap[i].finished()) {
63 terminou = false;
64 } else if (ap[i].hasResponse()) {
65 result = result
66 .multiply(new BigDecimal(ap[i].getResponse()));
67 }
68 }
69 }
70 // Imprime o resultado na tela.
71 System.out.println("Factorial " + number + "! = " + result);
72 }
73}
BorgProcess.java
Cada um dos processos criados por Borg.java é uma thread e faz uma conexão especifica com cada um servidor em funcionamento.
1/**
2 * Copyright 2001-2050 Saulo Popov Zambiasi. All rights reserved.
3 * Last modified: 2013/03/21
4 *
5 * Borg Process:
6 *
7 * Classe responsavel pela comunicacao de cada processo com um servidor.
8 * Envia uma mensagem e espera seu retorno.
9 */
10
11import java.io.*;
12import java.net.*;
13
14public class BorgProcess implements Runnable {
15 private String server; // IP ou nome do servidor
16 private String message; // Mensagem
17 private String response; // Mensagem recebida;
18 private int port; // Porta da conexao
19 private boolean done; // Trabalho terminado
20 private Thread runner;
21
22 BorgProcess(String server, int port, String message) {
23 this.message = message;
24 this.response = null;
25 this.server = server;
26 this.port = 4400;
27 this.done = false;
28 if (port != 0) {
29 this.port = port;
30 }
31 if (runner == null) {
32 runner = new Thread(this);
33 runner.start();
34 }
35 }
36
37 public void run() {
38 try {
39 // Conexao com o daemon
40 Socket conexao = new Socket(server, port);
41 conexao.setSoTimeout(20000);
42
43 // Envia a mensagem para o servidor
44 System.out.println("borg://" + server + ":" + port + "/send \""
45 + message + "\"");
46 BufferedOutputStream bos = new BufferedOutputStream(
47 conexao.getOutputStream());
48 PrintWriter os = new PrintWriter(bos, false);
49 os.println(message);
50 os.flush();
51 // recebe o resultado do daemon em forma de uma mensagem
52 BufferedReader in = new BufferedReader(new InputStreamReader(
53 conexao.getInputStream()));
54 response = in.readLine();
55 System.out.println("borg://" + server + ":" + port + "/recv \""
56 + response + "\"");
57 conexao.close();
58 } catch (IOException e) {
59 System.out.println("Erro: " + e.getMessage());
60 }
61 done = true;
62 }
63
64 String getResponse() {
65 String out = response;
66 response = null;
67 return out;
68 }
69
70 boolean hasResponse() {
71 return response != null;
72 }
73
74 boolean finished() {
75 return done;
76 }
77}
BorgServer.java
Servidor responsável por executar uma tarefa especifica.
1/**
2 * Copyright 2001-2050 Saulo Popov Zambiasi. All rights reserved.
3 * Last modified: 2013/05/21
4 *
5 * Borg Server: Executa as mensagens recebidas e retorna o resultado
6 */
7
8import java.io.*;
9import java.math.BigDecimal;
10import java.net.*;
11import java.util.*;
12
13public class BorgServer extends Thread {
14 private ServerSocket sock; // Socket do servidor
15
16 // Construtor que inicializa a classe como thread
17 public BorgServer(int port) {
18 super();
19 int serverPort = 4400;
20 if (port != 0)
21 serverPort = port;
22 try {
23 sock = new ServerSocket(serverPort);
24 System.out.println("Borg Server running...");
25 } catch (IOException e) {
26 System.out.println("Erro: " + e.getMessage());
27 System.exit(1);
28 }
29 start();
30 }
31
32 // Mantem o servidor em execucao
33 public void run() {
34 while (true) {
35 // Fica esperando o recebimento de mensagens
36 if (sock == null) {
37 return;
38 }
39 try {
40 Socket conn = sock.accept();
41 // Recebendo mensagem
42 BufferedReader in = new BufferedReader(new InputStreamReader(
43 conn.getInputStream()));
44 String message = in.readLine();
45 System.out.println("borg://" + conn.getInetAddress() + ":"
46 + conn.getPort() + "/recv \"" + message + "\"");
47 // executando a mensagem
48 message = execute(message);
49 // Enviando a resposta
50 BufferedOutputStream bos = new BufferedOutputStream(
51 conn.getOutputStream());
52 PrintWriter os = new PrintWriter(bos, false);
53 System.out.println("borg::/" + conn.getInetAddress() + ":"
54 + conn.getPort() + "/send \"" + message + "\"");
55 os.println(message);
56 os.flush();
57 os.close();
58 conn.close();
59 } catch (IOException e) {
60 System.out.println("Erro: " + e.getMessage());
61 System.exit(1);
62 }
63 }
64 }
65
66 String execute(String msg) {
67 String result = "null";
68 StringTokenizer split = new StringTokenizer(msg, " ");
69 // Verifica o comando, 1a. palavra da mensagem
70 String command = split.nextToken();
71 // Executa o comando de fatorial
72 switch (command) {
73 case "fatorial":
74 int a = Integer.parseInt(split.nextToken());
75 int b = Integer.parseInt(split.nextToken());
76 // long c = 1;
77 BigDecimal c = new BigDecimal("1");
78 for (int i = a; i <= b; i++) {
79 c = c.multiply(new BigDecimal(Integer.toString(i)));
80 }
81 result = c.toString();
82 break;
83 case "somatorio": // Outro exemplo
84 double total = 0;
85 for (int i = 0; i < split.countTokens() - 1; i++) {
86 total += Double.parseDouble(split.nextToken());
87 }
88 result = Double.toString(total);
89 break;
90 }
91 return result;
92 }
93
94 // Programa principal
95 public static void main(String[] arguments) {
96 // Configura a porta, caso passada por parametro.
97 int port = 0;
98 if (arguments.length == 1) {
99 port = Integer.parseInt(arguments[0]);
100 } else if (arguments.length > 1) {
101 System.out.println("Use: java Borgd port");
102 return;
103 }
104 new BorgServer(port);
105 }
106}
