Primitivas de Configuração

No nível de configuração, um conjunto de rotinas está a disposição do programador, sendo estas as mesmas que suportam a linguagem de mais alto nível utilizada para a composição e gerenciamento de aplicações, por parte do console. Estas rotinas de configuração, simplificam a obtenção dos requisitos típicos de uma aplicação, facilitando a construção de sistemas e a reutilização de módulos. Adicionalmente, estas rotinas podem ser utilizadas em tarefas de reconfiguração dinâmica, por não existirem limitações temporais para a aplicação das mesmas. Para um correto funcionamento das primitivas de configuração e comunicação, um sistema de nomeação global foi implementado. No nível mais alto, é utilizada uma nomeação orientada à aplicação e ao domínio, sendo apresentada em maior detalhe na seção 5.4. No entanto, existe uma outra nomeação interna, baseada em uma representação de mais baixo nível. Neste caso, cada módulo é representado por um identificador numérico único dentro do ambiente. As estações e os pinos de comunicação, por outro lado, seguem sendo representados pelos seus nomes simbólicos.

int info = CREATE_ST( char *station )

A rotina CREATE_ST() instancia uma estação física de nome station dentro do ambiente P-RIO. Se CREATE_ST() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

int mid = CREATE_MD( char *name, char **args, int flags, char *where )

A rotina CREATE_MD() instancia uma classe de módulo dentro do sistema com o código executável de nome name e argumentos args. A instanciação é feita na estação ou arquitetura

where (dependendo do valor assinado a flags). Se CREATE_MD() é realizada com sucesso

mid será um número positivo que identificará a instância criada, se algum erro ocorre, mid será menor que 0. O parâmetro flags permite determinar as condições de instanciação do módulo, podendo ser a soma não-exclusiva das constantes apresentadas na tabela 3. Se for especificado o modo de depuração (DEBUGGER), o módulo instanciado será executado sob o controle da

ferramenta de depuração típica da plataforma (e.g. dbx, xdb, dbg, udb, etc.).

Opção Valor Significado

DEFAULT 0x00 Sem nenhuma opção especial

PRIOSTAT 0x01 where especifica uma estação particular PRIOARCH 0x02 where especifica uma arquitetura específica DEBUGGER 0x04 Em modo de depuração

TRACING 0x08 Em modo de geração de dados para trace PRIOCOMP 0x10 Instanciação no complemento de where FRONTEND 0x20 Instanciado no MPP front-end

Tabela 3. Condições de Instanciação de um Módulo

int info = LINK(int mid1, char *pin1, int mid2, char *pin2)

A rotina LINK() liga o pino de saída chamado de pin1 no módulo de identificador mid1 ao pino de entrada chamado de pin2 no módulo de identificador mid2. A ligação de pinos é somente feita se os parâmetros de tipo, tamanho da mensagem e tamanho da resposta são complementares. Se LINK() é realizada com sucesso, info será igual a zero, se algum erro ocorre, info será menor que zero.

int info = LINKGROUPTO( char *group, int mid, char *pin )

A rotina LINKGROUPTO() liga o grupo de nome group ao pino de entrada chamado de pin no módulo de identificador mid. Todas as mensagens enviadas pelos pinos de saída ligados a

group, serão recebidas por este pino. Na primeira referência ao grupo group é criada a respectiva estrutura de dados, sendo especificadas nesse momento as características do mesmo (i.e. tipo, tamanho da mensagem, tamanho da resposta, etc.). A ligação ao pino é somente feita se os parâmetros de tipo, tamanho da mensagem e tamanho da resposta são coincidentes aos já existentes para o grupo. Se LINKGROUPTO() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

int info = LINKTOGROUP( int mid, char *pin, char *group )

A rotina LINKTOGROUP() liga o pino de saída chamado de pin do módulo de identificador

mid ao grupo de nome group. Toda mensagem enviada por este pino será recebida por todos os pinos de entrada ligados a group. Igualmente à primitiva LINKGROUPTO(), a ligação do

pino é somente feita se os parâmetros de tipo, tamanho da mensagem e tamanho da resposta são coincidentes aos já existentes para o grupo. Se o pino ligado ao grupo for síncrono, cada vez que uma mensagem é por ele enviada, deverão ser recebidas tantas respostas quantos pinos de entrada conectados ao grupo existam.

int info = REMOVE_MD( int mid )

A rotina REMOVE_MD() elimina o módulo com identificador mid do ambiente P-RIO. Esta rotina mata o processo UNIX associado ao módulo, liberando, assim, todas as suas estruturas de dados. Se REMOVE_MD() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

int info = REMOVE_ST( char *station )

A rotina REMOVE_ST() elimina todos os módulos existentes na estação física de nome

station. Se REMOVE_ST() é realizada com sucesso, info será igual a 0, se algum erro ocorre,

info será menor que 0.

int info = RESET_SYS( void )

A rotina RESET_SYS() elimina todos os módulos existentes no ambiente P-RIO, com exceção dos processos próprios do ambiente.

int info = REMOVE_LK( int mid, char *pin )

A rotina REMOVE_LK() elimina todas as conexões que existem desde, ou para, o pino chamado de pin no módulo com identificador mid. Isto inclui às ligações de grupo que possam estar associadas a esse pino. Se REMOVE_LK() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

int info = BLOCK_MD( int mid )

A rotina BLOCK_MD() bloqueia indefinidamente a execução do módulo instanciado com o identificador mid. Se BLOCK_MD() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

int info = BLOCK_ST( char *station )

A rotina BLOCK_ST() bloqueia indefinidamente a execução de todos os módulos instanciados dentro da estação física station. Se BLOCK_ST() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

int info = BLOCK_SYS( void )

A rotina BLOCK_SYS() bloqueia indefinidamente a execução de todos os módulos instanciados dentro do ambiente P-RIO.

int info = UNBLOCK_MD( int mid )

A rotina UNBLOCK_MD() reinicia a execução do módulo instanciado com identificador mid, previamente bloqueado. O bloqueio de um módulo é único, ou seja, não importa o número de primitivas de bloqueio recebidas, basta só uma primitiva de desbloqueio para reiniciar a execução do mesmo. Se o módulo indicado não estiver bloqueado, nenhuma ação ocorrerá.

int info = UNBLOCK_ST( char *station )

A rotina UNBLOCK_ST() reinicia a execução de todos os módulos bloqueados dentro da estação física station. Se UNBLOCK_ST() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

int info = UNBLOCK_SYS( void )

A rotina UNBLOCK_SYS() reinicia a execução de todos os módulos bloqueados dentro do ambiente P-RIO. Se UNBLOCK_SYS() é realizada com sucesso, info será igual a 0, se algum erro ocorre, info será menor que 0.

5.4. A Linguagem de Configuração

Todos os conceitos utilizados pela metodologia estão a disposição em uma linguagem de alto nível chamada de configuração ou coordenação, permitindo a construção de aplicações com base na composição de módulos básicos ou compostos já existentes. A sintaxe da linguagem

tenta se aproximar das linguagens orientadas a objetos, sendo sua implementação feita através da interpretação de um parser escrito em Tcl (Tool Command Language)^[44].

Com propósitos de coerência, existe uma ligação entre a linguagem de configuração e a linguagem de programação dos módulos individuais. A ligação está especificamente relacionada com a definição dos pinos e tipos utilizados. Esta ligação está baseada no uso de um pré-processador, podendo versões futuras adotar o uso de um compilador embutido no ambiente.

A seguir, são detalhados brevemente os comandos básicos fornecidos pela linguagem de configuração para a criação e gerenciamento de aplicações.

DEFINIÇÃO DE PINOS

O comando básico para definir um novo tipo de pino, chamado de PinClass, é:

pin_class PinClass type { sync data_m size_m data_r size_r } onde type pode tomar o valor “in” ou “out”, e sync pode ser “sync” ou “async”. Os parâmetros

data_m e data_r são os tipos de dados usados pelo pino para o envio das mensagens e para a recepção das respostas, respectivamente. Por outro lado, size_m e size_r são o número de dados enviados na mensagem e recebidos na resposta, respectivamente.

DEFINIÇÃO DE CONECTORES

Um conector agrupa um conjunto de pinos básicos e/ou outros conectores, com fins de configuração. Cada um dos elementos envolvidos pode estar ou não complementado (mediante o sufixo par), sendo feita a definição de um tipo de conector através da estrutura detalhada a seguir:

connector_class ConnectorClass { pin PinClass_1 pinname_1; pin_par PinClass_2 pinname_2;

connector ConnectorClass_1 pinname_3; connector_par ConnectorClass_2 pinname_4; . . . .

DEFINIÇÃO DE MÓDULOS

Cada módulo pode aceitar uma série de parâmetros, além de possuir um ou mais conectores de tipos anteriormente definidos. No caso dos módulos simples, tem-se também associado um código executável que implementa os métodos da classe. A sintaxe para definir uma classe de módulo é detalhada a seguir.

class Class { parameters } { code C “name args”;

connector Connector_1 pinname_1; connector_par Connector_2 pinname_2; . . . .

}

DEFINIÇÃO DE GRUPOS

A abstração de grupo está suportada pela definição apresentada a seguir, onde o parâmetro

ConnectorClass é igual a um dos tipos de connectores anteriormente definidos. group ConnectorClass name

INSTANCIAÇÃO DE MÓDULOS

Um módulo, previamente definido, pode ser instanciado da seguinte maneira: Class name “parameters” [on|at] arch;

onde parameters são os parâmetros passados à classe do módulo, e arch é um valor opcional que define a máquina (para o caso de on) ou a arquitetura (para o caso de at) onde vai ser instanciado o módulo.

LIGAÇÃO DE CONECTORES

Os conectores podem ser ligados entre eles, ou a grupos previamente definidos, através do comando link. Como um parâmetro opcional da ligação, pode ser especificado o protocolo utilizado. Alguns exemplos deste comando são listados a seguir:

link source.connector_1 drain.connector_1; link group_1 drain.connector_2 with UDP; link source.connector_2 group_2;

EXPORTAÇÃO DE CONECTORES

Ao trabalhar com módulos compostos é interessante poder ligar os conectores de módulos internos com os conectores exportados pelo módulo superior. A sintaxe para tal ligação, é mostrada a seguir:

attach instance.connector out_connector;

DEFINIÇÃO DE CLASSES COMPOSTAS

A título de exemplo, é apresentada, a seguir, a construção de uma classe composta utilizando a linguagem de configuração, e a sua posterior instanciação:

pin_class Connector1 in { sync int 2 char 1 } pin_class Connector2 out { async double 1 int 0 } class Class { parameters1 } {

connector Connector1 input; class Class1 { } {

code C “name”;

connector Connector1 input; connector Connector2 output; }

class Class2 { parameters2 } { . . . .

connector_par Connector2 data; . . . .

}

Class1 module1 at LINUX; Class2 module2 on Hydra;

link module1.output module2.data; attach module1.input input;

}

Class example variable;

Várias instruções para controle de fluxo, replicadores e condicionais são fornecidas para a configuração de aplicações. As mais utilizadas são apresentadas a seguir:

while { $pin == “input” } { . . . . } forall i 5 { . . . . } if { $i < 4 } { . . . . }

As variáveis utilizadas na linguagem são definidas e manipuladas da mesma forma que nos

scripts Tcl^[44].

5.5. Resumo

Neste capítulo foi apresentada uma visão geral da arquitetura do ambiente P-RIO, colocando ênfase no suporte à operação. Foi analisada a base fornecida por PVM e o suporte construído pelo ambiente, especialmente no referente ao subsistema de comunicação. Foram também detalhadas as primitivas de programação presentes na metodologia, junto com uma breve descrição da linguagem de configuração utilizada para a construção de aplicações.