Espaço de Tuplas (conceito e implementações: JavaSpaces, Linda e Lime)

CONCEITO
Um espaço de tuplas tem como função criar uma abstração de memória compartilhada sobre um sistema distribuído, onde todos podem ler e escrever no mesmo. Porém, na realidade os objetos estão dispostos nas memórias dos nós de cada sistema distribuído.
IMPLEMENTAÇÕES
• JavaSpaces
O espaço de tuplas JavaSpaces é um dos mais populares espaços de tuplas para a linguagem Java. As instruções abaixo descrevem como criar programas que compartilhem memória utilizando o JavaSpaces. Será utilizada a implementação do JavaSpaces do JINI e uma classe auxiliar para conectar ao serviço JavaSpace.

Código:
// Definindo o Formato das Mensagens

import net.jini.core.entry.Entry;
public class Message implements Entry {
public String content;
public Message() { } }

// Escrevendo no Espaço de Tuplas

import net.jini.space.JavaSpace;
import java.util.Scanner;
public class WriteMessage {
public static void main(String[] args) {
try {
System.out.println("Procurando pelo serviço JavaSpace...");
Lookup finder = new Lookup(JavaSpace.class);
JavaSpace space = (JavaSpace) finder.getService();
if (space == null) {
System.out.println("O serviço JavaSpace não foi encontrado. Encerrando...");
System.exit(-1); }
System.out.println("O serviço JavaSpace foi encontrado.");
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("Entre com o texto da mensagem (ENTER para sair): ");
String message = scanner.nextLine();
if (message == null || message.equals("")) {
System.exit(0); }
Message msg = new Message();
msg.content = message;
space.write(msg, null, 60 * 1000); }
} catch (Exception e) { e.printStackTrace(); } } }
// Lendo Mensagens do Espaço de Tuplas
import net.jini.space.JavaSpace;
public class ReadMessage {
public static void main(String[] args) {
try {
System.out.println("Procurando pelo serviço JavaSpace...");
Lookup finder = new Lookup(JavaSpace.class);
JavaSpace space = (JavaSpace) finder.getService();
if (space == null) {
System.out.println("O serviço JavaSpace não foi encontrado. Encerrando...");
System.exit(-1); }
System.out.println("O serviço JavaSpace foi encontrado.");
while (true) {
Message template = new Message();
Message msg = (Message) space.take(template, null, 60 * 1000);
if (msg == null) {
System.out.println("Tempo de espera esgotado. Encerrando...");
System.exit(0); }
System.out.println("Mensagem recebida: "+ msg.content) }
} catch (Exception e) {
e.printStackTrace(); } } }

• Linda

Linda possui seis operações apenas, duas de escrita (out e eval) e quatro de leitura (in, inp, rd e rdp). Nesta seção, a apresentação das operações é acompanhada por exemplos escritos em C-Linda.
• Operação para colocar tuplas no TS (Espaço de tuplas – Tuplas Spaces)
- OUT (expr1, expr2,..., exprn) -> tupla adicionada ao espaço de tuplas
• Operação para retirar tuplas de TS
- IN (c1, c2,..., cn) -> tupla satisfazendo template é retirada do espaço de tuplas
• Exemplo:
Tupla em TS: ("sinal",5,3)
Código:
INT A, B
A=5
IN ("sinal", 5, ?B) ou IN ("sinal", A, ?B)
Depois da execução: B=3 e tupla não existe mais.
• Operação para consultar tupla em TS
- RD (c1, c2,..., cn) -> tupla é lida, mas permanece no espaço de tuplas
• Exemplo:
Tupla em TS: ("sinal",5,3)
Código:
INT A, B
A=5
RD("sinal",5,?B) ou RD("sinal",A,?B)
Depois da execução: B=3 e tupla permanece em TS
• Tanto o IN como o RD são “bloqueantes” os processos ficam bloqueados até que apareça no espaço de tuplas, uma tupla que case com a pedida.
• Operação para criar um novo processo: Concorrência
- EVAL (c1, c2,..., cn) -> funciona como out, mas um novo processo é criado para associar a tupla.
• Exemplo:
Tupla em TS: ("sinal",5,3)
Código:
EVAL ("novoproc", x, f(x))
Depois da execução: Um novo processo é criado para executar f(x).

• Lime
Lime (Linda in a Mobile Environment) é um middleware projetado para possibilitar o desenvolvimento rápido de aplicações que apresentam mobilidade física (hosts) e/ou lógica (agentes). Ele adapta o espaço de tuplas do Linda para ambientes móveis através da quebra da noção de um espaço de tuplas global, ou seja, o conteúdo encontra-se distribuído através dos múltiplos componentes móveis.

Em Lime, cada agente possui espaços de tuplas próprios, que ele leva consigo a tiracolo, chamados ITS (interface tuplespace). Quando o agente se fixa em um host, seus ITSs são fundidos a um espaço de tuplas local e as tuplas passam a ficar visíveis para os demais agentes acoplados ao host. Ao deixar o host, o agente leva consigo os ITSs com as tuplas.

• Links

http://www.teses.usp.br/teses/disponiveis/55/55134/tde-08032003-012015/ (espaços de tuplas)
http://www.inf.ufsc.br/~frank/INE6514/JavaSpaces/ (javaspaces)
http://www.inf.puc-rio.br/~noemi/victal/linda.html (linda)
http://www.cin.ufpe.br/~vvs/cows/cowsPaper.pdf (Lime)