Nome

Anahy - Ambiente de Programacao para PAD (Processamento de Alto Desempenho)

Sinopse


#include <athread.h>

int aInit(&argc, &argv);
int aTerminate();
int athread_create(*th, *atrib, *(*func)(void*), *in);
int athread_join(th, **res);
int athread_exit(status);
int athread_attr_init(attr);
int athread_attr_destroy(attr);

Descrição

Anahy é um ambiente de programação (biblioteca compartilhada libathread) para PAD (Processamento de Alto Desempenho), que implementa o modelo de threads M:N e encontra-se operacional em arquiteturas SMP (Symmetric Multi-Processing).

O desenvolvimento do ambiente foi concebido de forma a permitir compatibilidade com o padrão POSIX para threads (IEEE P 100.3c). Desta forma as primitivas e estruturas oferecidas são um subconjunto dos serviços oferecidos por este padrão.

A programação em Anahy assemelha-se a em threads POSIX, diferenciando, apenas, na inclusão de duas funções, uma de inicialização (aInit) e outra de finalização (aTerminate), responsáveis pelo tratamento e gerenciamento dos VPS (Processadores Virtuais).

Uma breve descricao da API é descrita na proxima Sessão, seguida de instruções de Compilação e Executação de aplicativos e de um Exemplo Simples. No final desta manpage encontram-se os nomes dos membros do projeto bem como dos colaboradores.

LibAthread API

int aInit (&argc, &argv)

Inicializa a biblioteca a partir de um vetor de argumentos passados para o programa através da chamada do console. aInit mapeia argv em busca de palavras-chave (--hostfile, --nhosts, --port e --vps) e seus valores e o altera para um novo vetor argv sem estes argumentos da biblioteca. Maiores informacoes em Compilando e Executando.

aInit retorna um inteiro. Retorna 0 (zero) em caso de sucesso e um valor diferente se falhar.

int athread_create (athread_t *th, athread_attr_t *atrib, void *(*func)(void*), void *in)

Cria um novo fluxo de execução e o faz executável. Normalmente a primeira chamada esta localizada em main() como um processo único. Uma vez criada, pode disparar novos fluxos.

O novo fluxo de execução disparado trata-se da funcao func, com argumento in, é nutrido de um identificador único, pelo qual serah posteriormente referenciado, th.

Os valores fornecidos por atrib definem atributos com os quais o programador determina características do novo fluxo de execução. Caso não existam atributos o valor deve ser NULL.

athread_create retorna um inteiro. Retorna 0 (zero) em caso de sucesso e um valor diferente se falhar.

int athread_join (athread_t th, void **res)

th identifica o fluxo que se deseja sincronizar e res o endereço para os dados de retorno do fluxo.

athread_join retorna um inteiro. Retorna 0 (zero) em caso de sucesso e um valor diferente se falhar.

int aTerminate()

Finaliza a biblioteca, encerrando as tarefas dos Processadores Virtuais, liberando a máquina.

aTerminate retorna um inteiro. Retorna 0 (zero) em caso de sucesso e um valor diferente se falhar.

Um exemplo que envolve a API do Anahy pode ser encontrado na Sessão Exemplo Simples

Compilando e Executando

Compilação

Anahy não utiliza pre-compiladores ou compilador proprio, e seus programas sao compilados diretamente com gcc ou g++, por exemplo, com a adição de uma nova FLAG de compilacao: -lathread. Exemplificando, a compilação de um programa cujo codigo fonte e DeepThought.c pode ser feita:

gcc DeepThought.c -o DeepThought.bin -lathread

A partir de uma instalacao padrao (com ./configure --prefix=/usr), o caminho para a biblioteca Anahy e /usr/lib/, com os headers em /usr/include/. Desta forma nenhuma alteracao e necessaria para a compilacao ou execucao do programa.

Caso a compilacao de Anahy tenha --prefix= setado em outro diretório, outras FLAGS de compilação sao necessárias:

gcc DeepThought.c -o DeepThought.bin -lathread \
-I/caminho/para/Anahy/include/ -L/caminho/para/Anahy/lib/

onde -I/caminho/para/Anahy/include/ indica o caminho para os arquivos de include, e -L/caminho/para/Anahy/lib/ o caminho para a biblioteca.

Execução

A execução de um programa Anahy requer que o aplicativo enxergue a biblioteca. Novamente se ele tiver uma instalação padrão, não serão necessárias modificações para a execução:

./DeepThought.bin

Para compilação em outro local se faz necessário o ajuste da variável de ambiente $LD_LIBRARY_PATH, exportando-a com o caminho da libathread:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/caminho/para/Anahy/lib/

antes de executar.

É possível passar parametros, durante a chamada do aplicativo, referentes ao núcleo da biblioteca Anahy que serão processados por aInit.

Relaçào de parametros:

--hostfile=arquivo; -h arquivo

Arquivo que define as maquinas que executarãp a aplicação na versão distribuida de Anahy. O arquivo arquivo contém uma lista com o nome dos nodos e seus ips.

Modelo de arquivo:
terra   10.16.165.42
nodo01  10.16.165.01
nodo02  10.16.165.02
nodo03  10.16.165.03
nodo04  10.16.165.04
nodo05  10.16.165.05
nodo06  10.16.165.06
nodo07  10.16.165.07

Anahy atribui a primeira linha do arquivo de hosts como nodo mestre.

Exemplo:
./DeepThought.bin --hostfile=maquinas

--nhosts=N; -n N

Define o numero de nodos que serão utilizados do arquivo de hosts.

Exemplo:
./DeepThought.bin --hostfile=maquinas --nhosts=3

--port=N; -p N

Define as portas que serão utilizadas para a comunicacção entre nos nodos.

Exemplo:
./DeepThought.bin --hostfile=maquinas --port=42

--vps=N; --vps N; -v N

Número de VPS (Processadores Virtuais) que serão utilizados durante a execuçã do programa. O numero de VPS deve ser maior ou igual a um, sendo que --vps=1 reflete uma execução sequencial da aplicação.

Exemplo:
./DeepThought.bin --vps=4

Exemplo Simples

Um simples exemplo que ilustra o uso da biblioteca:

#include <stdio.h>
#include <stdlib.h>
#include "athread.h"

void *fibo(void *);

int main (int argc, char **argv) {
    athread_t thread;
    int ret, n;

    /* inicializa a biblioteca Anahy */
    aInit(&argc, &argv);

    if (argc != 2) {
        printf ("syntax: %s [rabbits]\n", argv[0]);
        exit (EXIT_FAILURE);
    }

    n = atoi (argv[1]);

    /* Crie a Recupera a athread de main() */
    printf("Calculating fibonacci(%d)...\n", n);
    athread_create(&thread, NULL, fibo, (void *) n);
    athread_join(thread, (void *) &ret);
    printf("Result: %d\n", ret);

    /* Finaliza a biblioteca */
    ret = aTerminate();
    return ret;
}


void *fibo (void *void_rabbit) {
    athread_t thread, thread2;
    int rabbit, ret, ret2;

    rabbit = (ulong) void_rabbit;
    if (rabbit <= 2) {
        return((void *)1);
    } else {
        athread_create(&thread, NULL, fibo, (void *)(rabbit-1));
        athread_create(&thread2, NULL, fibo, (void *)(rabbit-2));
    }
    athread_join(thread, (void *) &ret);
    athread_join(thread2, (void *) &ret2);
    ret += ret2;
    return((void *) ((int)ret));
}

Copyright

Anahy esta sob GPL - 2004.

Equipe

Colaboradores

Veja Também

pthread_create(3), pthread_join(3), pthread_exit(3), pthread_attr_init(3)

Visite Anahy na web: http://anahy.org