Compute on iOS error: “Requesting a device failed”

[rizerco]

Hi, I’m trying to create an iOS and Mac app that does compute work using WGPU compute shaders. I have this working without issues on macOS, but on iOS I get the following error: Requesting a device failed.

This is my set-up code:

let instance = wgpu::Instance::new(wgpu::Backends::all());
let adapter = instance
    .request_adapter(&wgpu::RequestAdapterOptionsBase {
        power_preference: wgpu::PowerPreference::HighPerformance,
        force_fallback_adapter: false,
        compatible_surface: None,
    })
    .block_on()
    .ok_or(Error::new("Couldn’t create the adapter."))?;

let (device, queue) = adapter
    .request_device(&Default::default(), None)
    .block_on()
    .map_err(|error| Error::new(format!("Couldn’t request device: {}", error).as_str()))?;

Output: Couldn’t request device: Requesting a device failed

I know it’s possible to get WGPU working on iOS (here’s an example), but I can’t see what’s that different to my code compared to theirs. I’ve tried passing in a CAMetalLayer and creating a surface to pass to compatible_surface, but the result was the same.

As I said, it runs fine on macOS, and it also runs as an iPad app on Apple Silicon. However the error is shown when running in the simulator or on device.

Any help would be very much appreciated. Let me know if you need any more details.

Thanks!
Luke

[Gordon-F]

@rizerco All iOS adapters are LowPower. You can try change request adapter options:

.request_adapter(&wgpu::RequestAdapterOptionsBase {
        power_preference: wgpu::PowerPreference::LowPower, <---
        force_fallback_adapter: false,
        compatible_surface: None,
    })

Also, you can enumerate adapters and pick the right one:

for a in instance.enumerate_adapters(wgpu::Backends::all()) {
    log::info!("{:?}", a.get_info())
}

[cwfitzgerald]

Power preference should never exclude a device, just change the preference of which device is chosen if there are multiple.

[rizerco]

Hi @Gordon-F, thanks so much for your response. When I enumerate the adapters I get the following output:
AdapterInfo { name: "Apple A12 GPU", vendor: 0, device: 0, device_type: IntegratedGpu, driver: "", driver_info: "", backend: Metal }
It seems all is good there. I tried using LowPower, but as @cwfitzgerald suggested, that didn’t change things.
I’m wondering if I need to do something other than use the defaults in the call to request_device?

[Gordon-F]

@rizerco Sorry, I misread your question. You can't get a device, not an adapter. You can try DeviceDescriptor from hello-triangle example:

 let (device, queue) = adapter
  .request_device(
      &wgpu::DeviceDescriptor {
          label: None,
          features: wgpu::Features::empty(),
          // Make sure we use the texture resolution limits from the adapter, so we can support images the size of the swapchain.
          limits: wgpu::Limits::downlevel_webgl2_defaults()
              .using_resolution(adapter.limits()),
      },
      None,
  )
  .await

Also, you can set RUST_LOG environment variable (RUST_LOG=trace) and see what's going wrong in log.

[rizerco]

Great, that is allowing the device to be requested on iOS now. Thanks so much for your help!

For anyone else interested, the full working code for the set up is now:

let instance = wgpu::Instance::new(wgpu::Backends::all());
let adapter = instance
    .request_adapter(&wgpu::RequestAdapterOptionsBase {
        power_preference: wgpu::PowerPreference::HighPerformance,
        force_fallback_adapter: false,
        compatible_surface: None,
    })
    .block_on()
    .ok_or(Error::new("Couldn’t create the adapter."))?;

let device_descriptor = wgpu::DeviceDescriptor {
    label: None,
    features: wgpu::Features::empty(),
    limits: wgpu::Limits::downlevel_defaults().using_resolution(adapter.limits()),
};
let (device, queue) = adapter
    .request_device(&device_descriptor, None)
    .block_on()
    .map_err(|error| Error::new(format!("Couldn’t request device: {}", error).as_str()))?;