Comunicaçãoentre processos: Mensagens

(1)

Comunicação entre processos:

Mensagens

Nazareno Andrade

Universidade Federal de Campina Grande 02/2008

Sistemas Distribuídos

(2)

2

Fundamentos

Coordenando processos

Construíndo sistemas

Sistemas construídos

(3)

Fundamentos

Coordenando processos

– Mensagens (e fluxos): UDP, TCP, MPI, Enfileiramento, Gossiping

– RPC e objetos distribuídos: RMI – Mensagens vs. RPC

– Nomeação

– Sincronização e replicação

Construíndo sistemas

Sistemas construídos

(4)

4

Objetivos

Dominar primitivas usadas para a comunicação entre processos

Visão geral de paradigmas de comunicação entre

processos

(5)

Fundamental: Mensagens e RPC/RMI

Tudo é construído com TCP e UDP Mensagens

– Direto com primitivas TCP ou UDP

– Primitivas mais sofisticadas: MPI, enfileiramento, multicast, epidemias, boatos

RPC/RMI

– Abstração de nível mais alto que mensagens

(6)

6

(7)

Transporte: TCP, UDP

Tipicamente, um programador só lida com a camada de transporte

As camadas inferiores são responsáveis por enviar dados brutos sem garantias de:

– Recebimento – Ordem

– Integridade

A camada de transporte torna isso tratável para nós

(8)

8

TCP vs. UDP

Em resumo, confiabilidade vs. desempenho

– Propriedades do TCP não são sempre importantes

(9)

Antes de mais detalhes

Lembremos 2 ou 3 coisas

Camada de rede (no nosso caso IP):

– Responsável por comunicação best-effort de pacotes entre nós

– Pacotes podem seguir rotas diferentes ou não chegar

Camada de transporte:

– Comunicação entre processos

– Multiplexamos a comunicação do IP com portas

(10)

10

As primitivas mais básicas da comunicação entre processos são send e receive

– Se são bloqueantes, a comunicação é síncrona

Uma última abstração é o soquete:

message

agreed port any port

socket socket

Internet address = 138.37.88.249 Internet address = 138.37.94.248

other ports

client server

(11)

UDP: como e pra quê

UDP é o IP no nível do transporte

– Transmissão de datagramas convertidos em pacotes – Checksum opcional

– Nenhuma garantia de chegada ou ordenação – Não há retransmissão

(12)

12

Primitivas UDP

• Send() um datagrama, pode ser não-bloqueante

• Receive() bloqueante de um datagrama

– Recebe de qualquer fonte

– Pode ter um timeout de espera

Mensagens são ‘enviadas’ quando dadas ao IP e são postas em um buffer de recebimento no destino até o receive()

O que pode dar errado aqui?

(13)

Traduzindo em um modelo

Mensagens podem ser perdidas

– Nos buffers, por exemplo

A comunicação está sujeita a falhas de omissão Mensagens podem sair de ordem

– Seguindo caminhos diferentes no roteamento IP

A comunicação está desordenamento das msgs

Isso nos diz algo sobre que tipo de sistemas devemos

construir sobre o UDP

(14)

14

O UDP é útil!

Um monte de problemas pode ser solucionado no modelo UDP

– DNS, DCHP, traceroute, SNMP, NTP – Transmissão de vídeo

– Transmissão de áudio

– Utilização eficiente de banda em alto desempenho – ...

(15)

Exemplo UDP

(16)

16

TCP: como e para quê

TCP soma ao IP

– Confiabilidade

– Fluxos de dados (em conexões)

– Segmentação automática dos fluxos em pacotes

– Garantias com retransmissões, ordenação e checksums – Controle de fluxo

– Buffering

(TCP é uma mãe)

A que custo?

O que disso poderia ser feito sobre UDP? Haveria ganhos?

(17)

Primitivas TCP

accept() e connect() estabelecem uma conexão send() e receive() de bytes, não de datagramas Abstraem:

– Tamanhos de mensagem – Perdas de mensagens

– Diferenças na velocidade de envio e recebimento (fluxo) – Duplicação e ordenação de mensagens

– Destino das mensagens! (outro lado da conexão)

(18)

18

E o modelo disso?

Não há falhas de omissão ou desordenação de mensagens Timeouts escondem de você que o mundo é assíncrono Há falhas de fail-stop

– Mas quando a conexão cai, falhou o canal ou o processo?

Processos não detectam imediatamente que mensagem não foi recebida

– Têm que esperar o ack não vir

(19)

Exemplo TCP

(20)

20

Quando TCP, quando UDP

Comparemos quem usa um e outro:

UDP:

grupo 1: NTP, DHCP, DCP grupo 2: vídeo e áudio

TCP: HTTP, FTP, SMTP

Fora isso, hoje em dia, se usa UDP para driblar segurança que visa TCP

– NATs e alguns firewalls

(21)

Primitivas mais apropriadas para desenvolvedores

send() e receive() são primitivas

Comumente, é mais conveniente usar abstrações de nível mais alto:

– Comunicação 1 – N Multicast

– Comunicação eficiente em grupo MPI – Observer-like Enfileiramento

– Disseminação de informação Protocolos epidêmicos – ...

(Pra não falar em RPC/RMI)

(22)

22

Message Passing Interface: por que

Queremos simular uma placa de ferro recebendo calor de duas fontes

– Dividimos a placa em pedaços, pedaços em processadores – Simula t em um pedaço, comunica resultado com vizinhos – Até estabilizar

Que tipos de primitiva são úteis para computação paralela?

E se queremos poder rodar a aplicação em clusters de qualquer tamanho?

– E se fôssemos físicos?

(23)

MPI: O que é

Antes de MPI, mil empresas forneciam mil bibliotecas MPI é um padrão para o desenvolvimento de

aplicações paralelas com passagem de mensagens

– É muito usado

– Hoje existem mil implementações do padrão

Tudo que uma aplicação paralela pode querer:

– Comunicação ponto-a-ponto transparente, comunicação em grupo, abstrações para escrever aplicações portáveis...

(24)

24

Uma idéia

O básico para cada processo:

– MPI_INIT

– MPI_FINALIZE – MPI_COMM_SIZE – MPI_COMM_RANK – MPI_SEND

– MPI_RECV – MPI_BCAST – MPI_REDUCE

(25)

int main( int argc, char *argv[] ) { int n, myid, numprocs, i;

double mypi, pi, h, sum, x;

MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank(MPI_COMM_WORLD,&myid);

if (myid == 0) {

printf("Enter the number of intervals: (0 quits) "); scanf("%d",&n);

}

MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

if (n == 0) break; else { h = 1.0 / (double) n;

sum = 0.0;

for (i = myid + 1; i <= n; i += numprocs) { x = h * ((double)i - 0.5);

sum += (4.0 / (1.0 + x*x));

}

mypi = h * sum;

MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);

if (myid == 0) printf("pi is approximately %.16f, Error is %.16f\n", pi, fabs(pi - PI25DT)); }

}

(26)

26

Mais algumas primitivas MPI

MPI_send bloqueia até msg estar em buffer para envio MPI_Ssend bloqueia até destino receber mensagem MPI_Rsend dispensa handshake e é mais eficiente

– Só pode ser chamada se destino está em receive()

Isso dá uma idéia do mundo da otimização de

comunicação...

(27)

Enfileiramento (Message queueing)

E se queremos comunicação com o mínimo possível de acoplamento entre partes que se comunicam?

– Não quero saber a interface dos componentes lá fora – Não quero saber se os componentes estão online ou não – Não quero bloquear até eles receberem a mensagem

Mas quero comunicação confiável!

Email é assim

Sistemas baseados em publish/subscribe podem ser assim

(28)

28

Uso de enfileiramento

O princípio é que clientes põem mensagens em filas

– Filas são persistentes, implementadas por servidores – Destinos lêem mensagens de suas filas

Serve para aplicações pouquíssimo acopladas

– E.g.: Conectar diversas operações legadas

– Comunicação assíncrona e confiável: email entre apps.

Implementado com Message Oriented Middleware:

IBM WebSphere MQ, Java Messaging Service, JBoss Messaging – Admin instala e administra filas, aplicações usam-nas para se

comunicar

(29)

(30)

30

public class Chat implements javax.jms.MessageListener{

/* Run the Chat client */

public static void main(String [] args){

try{

// args[0]=topicName; args[1]=username; args[2]=password Chat chat = new Chat(args[0],args[1],args[2]);

// Read from command line

BufferedReader commandLine = new java.io.BufferedReader(new InputStreamReader(System.in));

// Loop until the word "exit" is typed while(true){

String s = commandLine.readLine( );

if (s.equalsIgnoreCase("exit")){

chat.close( );

System.exit(0);

} else chat.writeMessage(s);

}

} catch (Exception e){ e.printStackTrace( ); } (...)

}

(31)

public Chat(String topicName, String username, String password) throws Exception { InitialContext jndi = new InitialContext(env);

// Look up a JMS connection factory TopicConnectionFactory conFactory =

(TopicConnectionFactory)jndi.lookup("TopicConnectionFactory");

// Create a JMS connection TopicConnection connection =

conFactory.createTopicConnection(username,password);

// Create two JMS session objects TopicSession pubSession =

connection.createTopicSession(false,

Session.AUTO_ACKNOWLEDGE);

TopicSession subSession =

connection.createTopicSession(false,

Session.AUTO_ACKNOWLEDGE);

// Look up a JMS topic

Topic chatTopic = (Topic)jndi.lookup(topicName);

// Create a JMS publisher and subscriber TopicPublisher publisher =

pubSession.createPublisher(chatTopic);

TopicSubscriber subscriber =

subSession.createSubscriber(chatTopic);

// Set a JMS message listener

subscriber.setMessageListener(this);

// Start the JMS connection; allows messages to be delivered

(32)

32

/* Receive message from topic subscriber */

public void onMessage(Message message) { try {

TextMessage textMessage = (TextMessage) message;

String text = textMessage.getText( );

System.out.println(text);

} catch (JMSException jmse){ jmse.printStackTrace( ); } }

/* Create and send message using topic publisher */

protected void writeMessage(String text) throws JMSException { TextMessage message = pubSession.createTextMessage( );

message.setText(username+" : "+text);

publisher.publish(message);

}

(33)

Multicast

Comunicação 1 vários

A priori, existe no nível da rede (IP Multicasting)

– Quando tudo está configurado e permitido – Geralmente é feito sobre UDP

– Processos entram em um grupo de multicast tudo que é enviado para o grupo é recebido por todos nele

– Temos que limitar o alcance do multicast

Freqüentemente, fazemos no nível da aplicação

Note que broadcast é um caso particular de multicast

Broad/Multicast confiável e ordenado é uma primitiva poderosa

(34)

34

Exemplo com multicast

(35)

Boatos e Epidemias como algo útil

Problema: Muitos nós, uma informação que precisa ser difundida a todos periodicamente

– Solução 1: broadcasts o tempo todo – O que é melhor que isso?

– E se eu não conheço a topologia da rede?

(36)

36

Boatos e epidemias

Boatos e epidemias são duas coisas que se espalham eficientemente em topologias desconhecidas

– Essencialmente, boatos == epidemias

(37)

Protocolo básico de boato

De aplicação pra aplicação:

– Escolha de nós

– Informação a ser trocada – Consolidação da informação

(38)

38

Exemplos com epidemias e boatos

Disseminação é o uso básico, mas existe mais um mundo lá fora Disseminação da informação:

– Roteamento IP

Gerência de recursos:

– Quem é o servidor mais carregado no sistema?

– Visão comum para detecção de falhas

Computação:

– Se a cada rodada, v_i, v_k  (v_i + v_k)/2, alguma hora v_k será a média para todos os nós

• A partir disso, podemos estimar o tamanho de um sistema!

(39)

Onde estamos

Mensagens

– Primitivas básicas para envio e recebimento – Paradigmas mais sofisticados

RPC e RMI

(40)

40

RPC (e RMI)

Outra apresentação

(41)

RPC vs. Mensagens

RPC ou RMI:

– Transparências

– Facilidade de programação – Semântica clara

– Sincronismo na comunicação

Mensagens:

– Eficiência

– Síncrono ou assíncrono

– Heterogeneidade de plataformas e versões

(42)

42

Recapitulando

Mensagens (e fluxos)

– UDP – TCP – MPI

– Enfileiramento – Gossiping

RPC e objetos distribuídos: RMI

Mensagens vs. RPC

(43)

Mais sobre esse assunto

Mundo UDP/TCP:

– RCP, uma modificação do TCP para otimizar tempo de download

– Como o Skype usa UDP para contornar NATs

MPI:

– Como rodar uma aplicação MPI em um só processador para testá-la

Enfileiramento:

– Apache ActiveMQ, JMS

Gossiping:

– Introdução ao tema