Solar: uma proposta de middleware pervasivo

Os sistemas pervasivos funcionam de maneira muito isolada e acabam não tirando vantagem de todos os recursos disponíveis em outros sistemas.

Se os sistemas que utilizam computação onipresente pudessem compartilhar seus recursos (como sensores, infra-estrutura de software e hardware), o custo de cada sistema pervasivo seria muito reduzido.

Diversos ramos da ciência da computação precisam ser unidos e desenvolvidos para que essa infraestrutura comum possa ser oferecida aos sistemas pervasivos.

Neste contexto existem alguns projetos que oferecem propostas de soluções para algum destes problemas. Um destes projetos é o Solar da universidade de Darthmouth que é apresentado neste trabalho:

O Sistema do Projeto Solar é constituído de quatro tipos de elementos: Estrela, Planeta, Aplicação e sensores e operadores.

A estrela é o núcleo do sistema no Solar. Existe apenas uma estrela e as aplicações devem conhecer sua localização lógica. A estrela deve receber das aplicações as especificações dos dados que devem ser fornecidos a elas.

Os planetas tanto recebem da Estrela as informações referentes aos sensores e operadores necessários, tanto podem enviar informações à Estrela, entretanto informações podem ser trocadas também entre planetas não precisando passar essas informações pela Estrela, eles devem ainda fornecer as informações necessárias a Aplicação. Desta forma o Solar busca evitar que a Estrela seja gargalo do sistema.

A aplicação está interessada nas informações que são disponibilizadas pelos sensores e operadores para oferecer determinado serviço.

Os Sensores captam a informação bruta, como temperatura ambiente ou percentual de utilização da CPU de um computador.

Para tratar as informações captadas pelos sensores, existem os operadores. Os operadores modificam as informações dos sensores para que elas se ajustem aos parâmetros fornecidos pela aplicação.

Como exemplo de aplicações do Solar temos:

Doorbell: Esta aplicação consiste em informa a disponibilidade de uma pessoa em uma sala através de uma tela posicionada à porta. Por exemplo: O sistema tem um sensor no modem que informa se o telefone da sala está sendo utilizado ou não. No caso do telefone estar sendo utilizado, o status apresentado na tela é que tem alguém. Ou o sensor ainda informa a presença de pessoas na sala.

iNote: A segunda aplicação Solar é o iNote. Esta aplicação nada mais é do que um bloco de notas. Entretanto não um simples bloco de notas, mas um inteligente. O iNote é acionado quando a quando a presença do professor não é detectada em sua sala. As mensagens são apresentadas na mesma tela da aplicação Doorbell. O sistema ainda fornece informações sobre quem está próximo a interface, o aplicativo pesquisa se existe algum recado destinado àquela pessoa, caso exista, esse recado é apresentado. O usuário pode ainda responder o recado que será devidamente armazenado e apresentado ao destinatário em momento oportuno.

WhiteBoard: O WhiteBoard é uma aplicação que se dedica a armazenar as informações discutidas em determinada reunião.

Sua interface consiste de um quadro onde são anotados os assuntos discutidos na reunião: desenhos, principais tópicos, tarefas pendentes etc.

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)

Escalabilidade e eficiência em descoberta do conhecimento em grandes volumes de dados

Escalabilidade e eficiência em descoberta do conhecimento em grandes volumes de dados

A troca de informação e a informação propriamente dita se mostra bastante importante nos dias de hoje. Ela deve ser bem organizada e manuzeada por poderosas máquinas inteligentes. Vivemos hoje uma grande dificuldade de sobrecarga de informação, ou seja, temos muitas informações que podem ser significantes, e pouco tempo, ou capacidade computacional insuficiente para avaliá-la adequadamente. Descobrir novos e poderosos mecanismos para organizar, encontrar e analisar essa informação é essencial para encarar esse problema.
Porém, observamos também uma tendência de evolução dos mecanismos computacionais para os grandes sistemas distribuídos. Pois temos uma tendência forte para processamento paralelo. Os padrões de programação paralela e os respectivos ambientes de programação se expõem bastante inadequados para assegurar a escalabilidade e a eficiência de implementações paralelas de muitas aplicações atuais. Aplicações essas que chamamos de irregulares, já que a demanda computacional é fortemente dependente dos dados de entrada, podendo variar significamente em funções deles.
Desta forma consideramos que a extração automatizada de informações se mostra como um desafio para uma significativa parcela da comunidade de ciência da computação, abrangendo desde as arquiteturas dos computadores e das redes que os conectam até a sua aplicação a um contexto específico, passando por novos algorítimos e a sua paralelização.

FONTE: http://www.ic.unicamp.br/~cmbm/desafios_SBC/wagnermeira.pdf

Ivonei Silva Nunes/ 106040332