Como configurar Rust com OpenCL no Windows usando uma RX 580

---

@CanalQb no YouTube

---

Como configurar Rust com OpenCL no Windows usando uma RX 580

---

Sempre crie uma frase de segurança única para jogos, Airdrops e qualquer outra coisa de origem desconhecida, em vez de usar sua carteira principal.

---

Se você possui uma placa de vídeo AMD RX 580 e deseja aproveitá-la para tarefas de alto desempenho como computação paralela, este tutorial completo mostra como configurar o ambiente com a linguagem Rust e OpenCL no Windows.

Especificações técnicas da RX 580

• Arquitetura: Polaris
• Potência de processamento: até 6.2 TFLOPS
• Memória: 8 GB GDDR5
• Compatibilidade com OpenCL: versão 2.0

Verificar suporte OpenCL com GPU-Z

Baixe o utilitário GPU-Z para conferir se a opção "OpenCL" está ativada. Isso garante que o driver está corretamente instalado.

Instalar Rust no Windows

1. Acesse: rustup.rs
2. Execute o rustup-init.exe
3. Siga as instruções do terminal

Instalar Visual Studio Build Tools

O compilador MSVC é essencial para projetos Rust com bibliotecas como OpenCL.

• Instale o workload: C++ Build Tools
• Inclua o Windows 10 SDK
• Baixe aqui

Criar um novo projeto com OpenCL

cargo new opencl-chaves
cd opencl-chaves

Adicione ao Cargo.toml:

[dependencies]
ocl = "0.19"

Exemplo de Kernel OpenCL (kernels.cl)

__kernel void gerar_chave(__global ulong* resultados, ulong base) {
    int gid = get_global_id(0);
    resultados[gid] = base + gid;
}

Exemplo de código Rust

use ocl::{ProQue, Buffer};

fn main() {
    let src = std::fs::read_to_string("kernels.cl").expect("Erro ao ler kernel");
    let num_chaves = 1_000_000;
    let pro_que = ProQue::builder().src(src).dims(num_chaves).build().unwrap();
    let buffer = Buffer::builder().queue(pro_que.queue().clone()).len(num_chaves).build().unwrap();
    let base_chave: u64 = 1_000_000_000;

    let kernel = pro_que.kernel_builder("gerar_chave")
        .arg(&buffer)
        .arg(base_chave)
        .build().unwrap();

    unsafe { kernel.enq().unwrap(); }

    let mut resultado = vec![0u64; num_chaves];
    buffer.read(&mut resultado).enq().unwrap();

    for chave in resultado.iter().take(10) {
        println!("Chave gerada: {}", chave);
    }
}

Corrigindo erro: LNK1181

Se surgir o erro “não foi possível abrir o arquivo 'OpenCL.lib'”, faça o seguinte:

1. Baixe um SDK compatível:
   • OCL SDK Light (AMD)
   • Intel OpenCL SDK
2. Adicione o caminho da OpenCL.lib na variável de ambiente LIB

Configurar o build.rs

fn main() {
    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:libdir=C:\\Program Files (x86)\\OCL_SDK_Light\\lib\\x86_64");
    println!("cargo:include=C:\\Program Files (x86)\\OCL_SDK_Light\\include");
    println!("cargo:rustc-link-lib=dylib=OpenCL");
}

Benchmark: 100.000 chaves com std::time

use std::time::Instant;

fn main() {
    let start = Instant::now();
    for i in 0..100000 {
        println!("Chave gerada: {}", i);
    }
    println!("Tempo total: {:?}", start.elapsed());
}

Alternativa com crate opencl3

[dependencies]
opencl3 = "0.6"

Kernel OpenCL (key_gen.cl)

__kernel void key_gen(__global unsigned int *keys, unsigned int count) {
    int id = get_global_id(0);
    if (id < count) {
        keys[id] = id;
    }
}

Exemplo de código usando opencl2.1

use opencl3::device::{Device, get_devices};
use opencl3::context::Context;
use opencl3::program::Program;
use opencl3::command_queue::{CommandQueue, QueueProperties};
use opencl3::memory::Buffer;
use opencl3::kernel::Kernel;
use opencl3::platform::get_platforms;
use opencl3::types::cl_uint;
use std::time::Instant;

fn main() {
    let start = Instant::now();
    let num_chaves = 100000;
    let kernel_source = include_str!("key_gen.cl");

    let platforms = get_platforms().unwrap();
    let devices = get_devices(&platforms[0], opencl3::device::DeviceType::GPU).unwrap();
    let context = Context::new(&platforms[0], vec![devices[0].clone()]).unwrap();
    let queue = CommandQueue::create(&context, &devices[0], QueueProperties::NONE).unwrap();
    let program = Program::create_and_build_from_source(&context, kernel_source).unwrap();
    let kernel = Kernel::create(&program, "key_gen").unwrap();
    let buffer = Buffer::::create(&context, num_chaves as u32).unwrap();

    kernel.set_arg(0, &buffer).unwrap();
    kernel.set_arg(1, &(num_chaves as cl_uint)).unwrap();

    queue.enqueue_nd_range_kernel(&kernel, 1, None, &[num_chaves], None).unwrap();
    let mut result = vec![0u32; num_chaves];
    queue.enqueue_read_buffer(&buffer, true, 0, &mut result, &[]).unwrap();

    println!("Tempo total com OpenCL: {:?}", start.elapsed());
    for chave in result.iter().take(10) {
        println!("Chave: {}", chave);
    }
}

Conclusão

Agora você tem uma configuração funcional do Rust com OpenCL no Windows utilizando a GPU RX 580. Essa combinação permite gerar dados em larga escala com eficiência computacional.

Lembre-se: não invista recursos em ferramentas ou métodos que você não compreende totalmente. Avalie tecnicamente e individualmente cada proposta antes de aplicar tempo ou dinheiro.

Gostou do conteúdo? Compartilhe com outros desenvolvedores!

---

Tags: #RustLang; #OpenCL; #RX580