Unable to repro a bug, unsure if I'm running code wrong

[zanciks]

Hey all. I'm trying to work on #169 but I'm having some issues reproing the issue.
I don't want to clutter up the bug with my comments though, since I'm honestly not even sure if I'm running the code that I have correctly :P
I'm still new to GPU development and so would love some help 🙏

// lib.rs
#![allow(internal_features)]
#![feature(core_intrinsics)]
#![no_std]

use spirv_std::spirv;

#[spirv(compute(threads(1)))]
pub fn bsw() -> i32 {
    let number: i32 = -12345678;
    core::intrinsics::bswap(number)
}

// main.rs
#![allow(internal_features)]
#![feature(core_intrinsics)]
// crate name for testing is bswap
use bswap::bsw;

fn main() {
    let result = bsw();

    println!("{:08x}", -12345678);
    println!("{:08x}", result);
    println!("{:08x}", std::intrinsics::bswap(-12345678)); // to see if the spirv version matches calling bswap directly
}

Does this properly run the gpu code? The bsw() function has the spirv attribute so I assume that it would, but I'm not getting the issue which makes me think I'm running this code wrong. Are there steps I am missing here?

I'm simply getting the output:

    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.07s
     Running `target/debug/bswap`
ff439eb2
b29e43ff
b29e43ff

Any help would be appreciated, thank you!

Though with all of this said, I think that I already know how to fix the issue [just match over (u64, bool) instead of u64 and flip bytes] and have nearly finished and am ready for a PR, but I'd love to be able to test it first.

[LegNeato]

Ah, I already put up a fix for this! #174. We must have crossed in flight.

A couple of things:

1. When run on CPU, the spirv annotation goes away and it becomes a normal function. If there is a standard bswap intrinsic in Rust (looks like there is: https://doc.rust-lang.org/std/intrinsics/fn.bswap.html), it is likely using that.
2. You are unable to use println in shaders, so if you are printing it is most likely running on CPU. There is a debug_printf! macro that works on the GPU but that requires you to install the vulkan SDK and enable vulkan layers to see the output (I want to make it better and hook stuff up to println because it sucks from a UX perspective to be non-standard and I refuse to install the vulkan SDK / layers )
3. We don't actually have tests that run GPU code! 😨 I just found this out today when I put my PR up. We have compiletests which check that things compile, but we don't have tests that check the output of a running GPU program. I hope to polish up a WIP test harness I have to get that set up as it seems like a huge hole.

[zanciks]

Ah got it, thanks! I wasn't sure if it still went through the spirv_codegen crate or whatnot when running on the CPU.
It seems like much of what is being done (or really everything, in the case of bswap) is just normal rust code that could be run on the CPU. Is there an option/feature for that when importing spirv_std, or something similar? There might not really be a reason to do it, because in the normal case it should be the same anyway, but it might be nice for testing. I'm also still kinda learning about GPU code and such, so idk maybe its impossible haha

[LegNeato]

Yeah, so this is super confusing in general and I only really got a hang of it this month.

What is happening is that your main.rs code is being compiled and run on the CPU target by default. It is then importing your lib.rs code, again compiling and running on the CPU target. The #[spirv()] attribute has this nice/confusing property that if it is being compiled on on a target architecture that is not spirv (aka the CPU), it turns into a no-op.

So your lib.rs is effectively compiled for the CPU as:

// lib.rs
#![allow(internal_features)]
#![feature(core_intrinsics)]
#![no_std]

pub fn bsw() -> i32 {
    let number: i32 = -12345678;
    core::intrinsics::bswap(number)
}

That is just a standard Rust crate you could write without knowing anything about Rust GPU. When your compiled main.rs calls the compiled lib.rs bsw(), it is on the CPU and using the standard rust CPU-version of core::intrinsics::bswap, not the one in the Rust GPU project. This is why you do not see the failure, as the core::intrinsics::bswap works just fine 😄

In order to have code run on the GPU, you have to use SpirvBuilder from spirv_builder to compile the code for the GPU and then do a ton of ceremony on the host/ CPU side to load the code and send it to the GPU and trigger it to run. You can look at the examples in this repo (though they are more convoluted then they need to be) but the hope is @schell 's cargo-gpu will make this way, way easier.