Conteúdo


Conversão de representação de dados em tempo real em uma implementação distribuída usando funções nativas do InfoSphere Streams

Uso dos conceitos de sobrecarga de função de C++ com funções nativas do InfoSphere Streams®

Comments

Ao executar um aplicativo distribuído em tempo real, o desafio que qualquer desenvolvedor de aplicativo ou solução tem que enfrentar é a variação no formato dos dados. A primeira coisa a fazer é converter o formato, antes de continuar com a análise/processamento. Em uma solução em tempo real, os dados são provenientes de várias origens, que são executadas em várias arquiteturas. Quando os dados chegam de arquiteturas heterogêneas em formato binário bruto, os resultados podem ser inconsistentes ou incorretos. O IBM InfoSphere Streams oferece funções nativas para criar lógica customizada como funções reutilizadas, que podem ser chamadas por um aplicativo Streams Processing Language (SPL). Neste artigo, descreveremos como desenvolver as rotinas de conversão de formato de dados usando funções nativas e explorando os conceitos de sobrecarga de função do C++. Também descreveremos como usar essas funções como parte de uma solução Streams com a ajuda do InfoSphere Streams Studio. A arquitetura de implementação de alto nível é mostrada abaixo.

Figura 1. Conversão de formato de dados em tempo real
Conversão de formato de dados em tempo real
Conversão de formato de dados em tempo real

Pré-requisitos

  • Pré-requisitos de negócios: O público deste artigo deve ter conhecimentos básicos sobre design e execução de tarefas de aplicativos SPL do InfoSphere Streams e conhecimento intermediário de programação em C++.
  • Pré-requisitos de software: InfoSphere Streams 2.0 e superior.

Preparando o InfoSphere Streams Studio para desenvolvimento de função nativa

A seguir, as etapas para criar a nova função nativa.

  1. Crie um aplicativo SPL no Streams Studio.
  2. Clique no projeto e escolha o novo modelo de função SPL nativa para criar uma definição de função nativa.
  3. Para cada novo operador ou função nativa no Streams, um novo modelo de operador é criado, no qual toda configuração precisa ser especificada. Um fragmento do modelo de operador é mostrado na Figura 2.
  4. Configure o modelo de operador:
    • Especifique o nome do arquivo de cabeçalho que contém a lógica de função.
    • Especifique os protótipos de função, presentes no arquivo de cabeçalho.
    Figura 2. Dependência de biblioteca externa
    Dependência de biblioteca externa
    Dependência de biblioteca externa
  5. Os valores que precisam ser definidos para as várias seções no modelo de operador estão na Tabela 1.
Tablela 1. Várias propriedades de modelo de função nativa a serem configuradas
SeçãoPropriedadeDescriçãoValor
Function SetCpp Namespace NameMenciona o nome do namespace no qual as funções C++ são definidasDataConvertors
Header File NameContém o nome do arquivo de cabeçalho no qual as funções C++ são definidas. O arquivo de cabeçalho deve estar presente na pasta resources/impl dentro do aplicativo SPL.DataConvertors.h
Function Set > Prototypes (clique com o botão direito em new child and function)Prototype > ValueEspecifica o protótipo de função. O protótipo precisa fornecer todas as funções nativas no modelo de função.public void endian_swap(int64 x)

Código de função C++ para converter formatos de dados e integrar com o modelo de função nativa do InfoSphere Streams

Ao utilizar o conceito de sobrecarga de função do C++, é possível criar uma função separada para processar dados de vários tipos.

  • Com base no tipo, a função de conversão com o endian apropriado é chamada. Uma função nativa SPL estaria no formato especificado na Lista 1.
    • A seção include é onde todas as referências externas devem ser incluídas.
    • O nome do namespace da função e o nome devem ser os mesmos fornecidos no modelo de função.
    • A lógica de função para todas as funções nativas.
Lista 1. Formato da definição de função nativa no InfoSphere Streams
#include ..
                
namespace <namespace_name>
{
    ret_type swap_endian(parameters..)
    { 
    ...
    }
}

Abaixo está o fragmento de código de função nativo (Lista 2) que realiza a conversão de endian. Com base no tipo de parâmetro, a função apropriada é chamada.

Lista 2. O código de amostra demonstra a lógica para conversão de endian para entrada dos tipos short, long e int
void swap_endian(unsigned short& x)
{
    x = (x>>8) | 
    (x<<8);
}
                
void swap_endian(unsigned int& x)
{
    x = (x>>24) | 
    ((x<<8) & 0x00FF0000) |
    ((x>>8) & 0x0000FF00) |
    (x<<24);
}
                              
void swap_endian(unsigned long& x)
{
    x = (x>>56) | 
    ((x<<40) & 0x00FF000000000000) |
    ((x<<24) & 0x0000FF0000000000) |
    ((x<<8)  & 0x000000FF00000000) |
    ((x>>8)  & 0x00000000FF000000) |
    ((x>>24) & 0x0000000000FF0000) |
    ((x>>40) & 0x000000000000FF00) |
    (x<<56);
}

Usando a função nativa com o operador Functor no InfoSphere Streams usando SPL

Após a função nativa ser desenvolvida, a próxima etapa é usar a função em um aplicativo SPL para realizar a conversão de formato nos dados vindos de várias fontes em tempo real.

Abaixo está o código SPL de amostra do aplicativo que chama a função nativa dentro do operador Functor (Lista 3). O aplicativo lê a entrada de uma porta TCP e realiza a transliteração da entrada antes de propagá-la adiante.

InfoSphere Streams fornece vários adaptadores de origem e dissipador para ler e gravar dados. Qualquer número de dissipadores pode ser usado em um aplicativo SPL em tempo real.

Lista 3. Aplicativo SPL de amostra usando função nativa com o operador Functor para realizar a conversão de formato de dados
composite Main {
    graph
                
    stream<int32 inp> Src =  TCPSource()                                         
    {                                                                        
        param                                                                  
        role                : client;                                        
        address             : "inputdomain.com";                             
        port                : 23145u;                                         
    }                                    
    stream<list<float64> result> Funct = Functor(Src)
    {
        output
            Funct:result=swap_endian(Src.inp);
    }
                
    () as TCPWrite = TCPSink(Funct)
    {
        param
        address:"143.121.112.76";
        role : server;
        port : 21344u;
    } 
}

Você está pronto para iniciar a tarefa de conversão de formato de dados em tempo real. Desenvolva e execute a tarefa.

Condições excepcionais

  • InfoSphere Streams fornece um depurador que permite depurar o aplicativo em tempo real. O depurador do Streams tem vários comandos e opções, que podem ser usados para rastrear e validar a saída facilmente. Mais informações sobre o depurador em Debugging with the Streams Debugger.

Conclusão

Falamos sobre como realizar a conversão de formato de dados usando a função nativa do InfoSphere Streams. Explicamos as várias definições de configuração a serem realizadas e como isso pode ser feito no InfoSphere Streams. A conversão de formato de dados serve como um componente essencial para a resolução de resultados inconsistentes e incorretos devido à variação em arquiteturas em um ambiente distribuído.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Information Management
ArticleID=840131
ArticleTitle=Conversão de representação de dados em tempo real em uma implementação distribuída usando funções nativas do InfoSphere Streams
publish-date=10152012