Construindo um Módulo RTL para o Intel FPGA SDK for OpenCL

📚 Tabela de Conteúdos

1. Introdução ao treinamento
2. Motivação para escrever um módulo RTL personalizado
3. Empacotando o módulo RTL personalizado
4. Utilizando o módulo personalizado em seu código de kernel
5. Compilando o código com o módulo personalizado
6. Exemplo de implementação de um módulo RTL personalizado
7. Recursos adicionais
8. Conclusão

📝 Introdução ao treinamento

Bem-vindo a este treinamento sobre a construção de uma biblioteca RTO para o Intel FPGA SDK para OpenCL. Neste treinamento, discutiremos como escrever um módulo RTL em Vera log ou VHDL que pode ser usado como código de kernel OpenCL para um FPGA da Intel.

Antes de prosseguir com este treinamento, é importante entender o básico do uso do OpenCL com os FPGAs da Intel. Existem dois treinamentos online com duração de aproximadamente 45 minutos cada que o ajudarão a obter o conhecimento necessário para escrever programas OpenCL para os FPGAs da Intel.

Os treinamentos são:

• "Aprendendo a escrever programas OpenCL para FPGAs da Intel", que ensina os fundamentos da linguagem OpenCL e como escrever programas simples de host e kernels usando o OpenCL.
• "Executando o OpenCL em FPGAs da Intel", que ensina como usar o Intel FPGA SDK para OpenCL para compilar e executar seu código.

Neste treinamento, seguiremos a seguinte agenda:

1. Discussão sobre a escrita de um módulo RTO para uso com o OpenCL
2. Empacotamento do módulo para uso com o SDK
3. Utilização do módulo em seu kernel e como compilar o código resultante

🖋️ Motivação para escrever um módulo RTL personalizado

Existem duas razões principais para escrever um módulo personalizado:

1. Você já possui um design RTL otimizado e verificado que deseja usar sem precisar reescrevê-lo.
2. Você deseja implementar alguma funcionalidade que não pode ser expressa de forma eficaz em OpenCL para atender aos requisitos do seu sistema, como frequência de clock ou uso de recursos do FPGA.

Vamos prosseguir com a discussão dos detalhes técnicos da escrita de um módulo RTO.

➰ Empacotando o módulo RTL personalizado

Para usar seu módulo customizado com o SDK, você precisa empacotá-lo como uma biblioteca. Isso exigirá os arquivos RTL que você escreveu, bem como outros arquivos discutidos nesta apresentação.

Além disso, observe que você também pode empacotar código OpenCL que você escreveu como uma biblioteca, se desejar.

O módulo RTL que você escreverá será usado como uma função OpenCL com o código de kernel C. Portanto, o próximo passo será usar essa função no seu código de kernel quando você executar o compilador para compilar o código do kernel.

Isso resultará em um arquivo executável do compilador OpenCL ou um arquivo .xco que contém um fluxo de bits que pode ser carregado no FPGA.

Ao desenvolver um módulo customizado para uso com o SDK Intel FPGA para OpenCL, você pode usar Vera log, System Vera log ou VHDL. Todos os arquivos de origem devem ser de um desses tipos.

Também é importante observar que os nomes dos arquivos precisarão ser diferentes dos nomes dos arquivos RTL distribuídos como parte do SDK Intel FPGA para OpenCL. Se você tiver partes de IP que fazem parte do seu módulo, inclua os arquivos RTL gerados ao gerar esse IP em vez de um arquivo .qip.

🔧 Utilizando o módulo RTL personalizado em seu código de kernel

Usar seu módulo RTL personalizado dentro do seu código de kernel é simples e não é diferente de usar qualquer outra função em C no hardware. No seu arquivo .c do kernel, inclua o arquivo de cabeçalho do seu módulo personalizado adicionando a linha #include <nome_do_arquivo.h> no início do arquivo. Em seguida, use o módulo como faria com qualquer outra função em C dentro do seu código do kernel.

Quando você quiser compilar o kernel onde usou seu módulo RTL personalizado, siga estas etapas:

1. Crie um arquivo objeto que represente seu módulo personalizado usando o comando AOC -RTL compile, com o arquivo XML do seu módulo como entrada.
2. Empacote o arquivo objeto ou vários arquivos objeto em um arquivo de biblioteca usando o comando AOC -library create.
3. Ao compilar seu arquivo de teste C com o compilador AOC, use a opção -l para especificar o arquivo da biblioteca onde seu módulo personalizado está embalado. Se o arquivo da biblioteca estiver em um diretório diferente do diretório em que está compilando, use a opção -L <caminho_do_diretório> para indicar onde ele pode ser encontrado.

🛠️ Compilando o código com o módulo RTL personalizado

Ao compilar seu código de teste .c com o compilador AOC, é importante especificar o arquivo da biblioteca onde seu módulo personalizado está embalado. Se o arquivo da biblioteca estiver em um diretório diferente do diretório em que você está compilando, use a opção -L <caminho_do_diretório> para indicar o local onde ele pode ser encontrado.

A próxima etapa do seu aprendizado é examinar um exemplo de implementação de um módulo RTL personalizado. Existem exemplos completos disponíveis no website da Intel FPGA que podem ser compilados e executados em um sistema OpenCL.

Os exemplos incluem:

1. Um exemplo simples que implementa uma operação de swap de bytes em um número inteiro de entrada.
2. Um exemplo mais complexo que implementa o uso de uma interface mapeada à Memória do Avalon em um módulo personalizado.

Os exemplos podem ser encontrados no seguinte URL: [link dos exemplos]

Ao se preparar para implementar seu próprio módulo RTL personalizado, consulte as referências listadas aqui. O guia de programação do SDK Intel FPGA para OpenCL contém um capítulo dedicado às bibliotecas personalizadas e fornece informações mais detalhadas do que as fornecidas neste treinamento.

O website de suporte do SDK é o lugar para acessar documentação, exemplos de design, cursos de treinamento e muito mais.

Ao finalizar este treinamento, um link para uma pesquisa online curta foi enviado por e-mail para você. Por favor, preencha a pesquisa para nos informar sua opinião sobre este treinamento e se você tem sugestões de melhorias.

Obrigado por participar e aprender mais sobre as FPGAs da Intel!

🚀 Exemplo de implementação de um módulo RTL personalizado

Para ajudar você a entender melhor como implementar um módulo RTL personalizado, vamos dar uma olhada em um exemplo simples. Neste exemplo, mostraremos como implementar uma operação de swap de bytes em um número inteiro de entrada.

Primeiro, vamos definir o cabeçalho da função em um arquivo swap_bytes.h:

#ifndef SWAP_BYTES_H
#define SWAP_BYTES_H

int swap_bytes(int input);

#endif

Agora, vamos implementar a funcionalidade em um arquivo swap_bytes.c:

#include "swap_bytes.h"

int swap_bytes(int input) {
    int b0 = (input & 0x000000FF) << 24;
    int b1 = (input & 0x0000FF00) << 8;
    int b2 = (input & 0x00FF0000) >> 8;
    int b3 = (input & 0xFF000000) >> 24;

    return b0 | b1 | b2 | b3;
}

Em seguida, empacotamos o arquivo swap_bytes.o em uma biblioteca usando o seguinte comando:

gcc -c swap_bytes.c
ar rcs libswap_bytes.a swap_bytes.o

Agora, podemos usar esse módulo personalizado em nosso código de kernel. Aqui está um exemplo de código de kernel que faz uso do módulo swap_bytes para trocar os bytes de entrada:

#include <stdio.h>
#include "swap_bytes.h"

#define SIZE 4

void swap_bytes_kernel(int *input, int *output) {
    for (int i = 0; i < SIZE; i++) {
        output[i] = swap_bytes(input[i]);
    }
}

int main() {
    int input[SIZE] = {0x12345678, 0xAABBCCDD, 0x55555555, 0xAAAAAAAA};
    int output[SIZE];

    swap_bytes_kernel(input, output);

    for (int i = 0; i < SIZE; i++) {
        printf("Input: 0x%x, Output: 0x%x\n", input[i], output[i]);
    }

    return 0;
}

Ao executar o código acima, você verá a saída que mostra os valores de entrada e saída após a operação de troca de bytes:

Input: 0x12345678, Output: 0x78563412
Input: 0xAABBCCDD, Output: 0xDDCCBBAA
Input: 0x55555555, Output: 0x55555555
Input: 0xAAAAAAAA, Output: 0xAAAAAAAA

Espero que este exemplo tenha dado uma ideia de como implementar e usar um módulo RTL personalizado em seu código de kernel.

📚 Recursos adicionais

Aqui estão alguns recursos adicionais que podem ajudar você a aprender mais sobre o uso de módulos RTL personalizados com o Intel FPGA SDK para OpenCL:

• Documento de programação do Intel FPGA SDK para OpenCL - Este documento contém informações detalhadas sobre o uso de bibliotecas personalizadas e como integrar módulos RTL personalizados em seu implementação.
• Website de suporte do Intel FPGA SDK para OpenCL: www.intel.com/fpga/opencl - Este website contém documentação, exemplos de design, cursos de treinamento e muito mais.

🎓 Conclusão

Neste treinamento, discutimos como escrever um módulo RTL personalizado para usar com o Intel FPGA SDK para OpenCL. Vimos a motivação por trás da escrita de um módulo personalizado e como empacotá-lo como uma biblioteca.

Também aprendemos como usar o módulo personalizado em um código de kernel OpenCL e como compilar o código usando o módulo.

Lembre-se de que há exemplos completos disponíveis para você experimentar e explorar, e também há recursos adicionais disponíveis para aprofundar seu conhecimento.

Esperamos que este treinamento tenha sido útil e que você se sinta mais confiante para escrever e usar módulos RTL personalizados em seus projetos com o Intel FPGA SDK para OpenCL.

Se você tiver alguma dúvida, não hesite em entrar em contato com nossa equipe de suporte.

Obrigado por participar deste treinamento e boa sorte em seus futuros empreendimentos com FPGAs da Intel!

💡 Destaques

• Aprenda a escrever um módulo RTL personalizado para uso com FPGAs da Intel
• Empacote seu módulo como uma biblioteca para uso com o SDK Intel FPGA para OpenCL
• Utilize o módulo personalizado em seu código de kernel OpenCL
• Compile seu código usando o módulo personalizado
• Exemplo de implementação de um módulo RTL personalizado
• Recursos adicionais para aprendizado adicional
• Conclusão e próximos passos

❓ FAQ

Q: Quais são os requisitos para construir um módulo RTL personalizado? A: Os requisitos são ter um design RTL otimizado e verificado ou a necessidade de implementar alguma funcionalidade que não possa ser expressa de forma eficaz em OpenCL.

Q: Posso usar linguagens de descrição de hardware diferentes de Vera log, System Vera log ou VHDL? A: Não, é necessário usar uma dessas linguagens de descrição de hardware para o módulo RTL personalizado.

Q: É possível empacotar código OpenCL como uma biblioteca junto com o módulo RTL personalizado? A: Sim, é possível empacotar código OpenCL como uma biblioteca junto com o módulo RTL personalizado.

Q: Como posso usar o módulo RTL personalizado em meu código de kernel OpenCL? A: Basta incluir o cabeçalho do arquivo de módulo personalizado no início do seu arquivo de código de kernel e usar a função como qualquer outra função em C.

Q: Posso usar o módulo personalizado em uma implementação de FPGA de frequência de clock diferente? A: Sim, é possível usar o módulo personalizado em uma implementação de FPGA de frequência de clock diferente. Certifique-se de informar as propriedades corretas do módulo no arquivo XML fornecido ao compilador.

Q: O módulo personalizado pode se comunicar com memória externa? A: Sim, é possível que o módulo personalizado se comunique com memória externa. No entanto, é recomendado que isso seja feito apenas se for absolutamente necessário.

Q: Onde posso encontrar exemplos de implementação de módulos RTL personalizados? A: Você pode encontrar exemplos completos de implementação de módulos RTL personalizados no website da Intel FPGA.