unsafe fn create_io_buffers(
        adapter: &mut Adapter<back::Backend>,
        device: &<back::Backend as Backend>::Device,
    ) -> (
        u32,
        u32,
        <back::Backend as Backend>::Memory,
        <back::Backend as Backend>::Buffer,
        *mut u8,
        <back::Backend as Backend>::Buffer,
        *mut u8,
    ) {
        let buffer_length: u32 = 16384;
        let buffer_size: u32 = (mem::size_of::<i32>() as u32) * buffer_length;
        let memory_size: u64 = 2 * (buffer_size as u64);

        let mut in_buffer = device
            .create_buffer(buffer_size as u64, buffer::Usage::STORAGE)
            .unwrap();
        let mut out_buffer = device
            .create_buffer(buffer_size as u64, buffer::Usage::STORAGE)
            .unwrap();

        let in_buffer_req = device.get_buffer_requirements(&in_buffer);
        let out_buffer_req = device.get_buffer_requirements(&out_buffer);

        let memory_properties = adapter.physical_device.memory_properties();

        let memory_type_id: hal::MemoryTypeId = memory_properties
            .memory_types
            .iter()
            .enumerate()
            .position(|(id, mem_type)| {
                mem_type
                    .properties
                    .contains(memory::Properties::CPU_VISIBLE | memory::Properties::COHERENT)
                && in_buffer_req.type_mask & (1 << id) != 0
                && out_buffer_req.type_mask & (1 << id) != 0
                && memory_size < memory_properties.memory_heaps[mem_type.heap_index]
            })
            .unwrap()
            .into();

        let memory = device
            .allocate_memory(memory_type_id, memory_size)
            .unwrap();

        device
            .bind_buffer_memory(&memory, 0, &mut in_buffer)
            .unwrap();
        device
            .bind_buffer_memory(&memory, buffer_size as u64, &mut out_buffer)
            .unwrap();

        let payload = device
            .map_memory(&memory, (0 as u64)..(buffer_size as u64))
            .unwrap();
        let result = device
            .map_memory(&memory, (buffer_size as u64)..(memory_size as u64))
            .unwrap();

        (
            buffer_length,
            buffer_size,
            memory,
            in_buffer,
            payload,
            out_buffer,
            result,
        )
    }