Vulkan memory coherence guarantees when HOST_VISIBLE without HOST_COHERENT

Direct Answer

Yes, applications must implement explicit vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges paths for any memory type that lacks VK_MEMORY_PROPERTY_HOST_COHERENT_BIT. The spec guarantees nothing about cache coherence for HOST_VISIBLE alone; omitting flush/invalidate on non-coherent memory is undefined behavior, even if it appears to work on your development GPU.

Confirmed Facts

• HOST_VISIBLE ≠ coherent. The flag only means the memory can be mapped and accessed from the CPU. Cache coherence is a separate property.
• Non-coherent memory requires explicit operations. After host writes, call vkFlushMappedMemoryRanges before the device reads. Before host reads, call vkInvalidateMappedMemoryRanges after the device writes.
• Alignment is mandatory. Flushed/invalidated ranges must be aligned to VkPhysicalDeviceLimits::nonCoherentAtomSize (except ranges that reach the allocation end). Misaligned ranges are a validation error.
• Synchronization is separate. Flush/invalidate handle cache visibility; you still need fences/semaphores/events for execution ordering.

Portable Runtime Detection

1. Call vkGetPhysicalDeviceMemoryProperties once at startup.
2. For each memory type, check propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT and propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT.
3. Record nonCoherentAtomSize from VkPhysicalDeviceLimits.
4. Select a memory type that satisfies your usage flags. If a HOST_COHERENT type exists for your needs, prefer it — flush/invalidate become no-ops per spec.
5. If only non-coherent types are available (common on some tiled/mobile GPUs), implement the aligned flush/invalidate path.

Recommended Pattern

// At initialization
VkPhysicalDeviceMemoryProperties memProps;
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProps);
VkPhysicalDeviceProperties devProps;
vkGetPhysicalDeviceProperties(physicalDevice, &devProps);
const VkDeviceSize atomSize = devProps.limits.nonCoherentAtomSize;

// When choosing a memory type for host-visible buffers
bool needsExplicitFlush = false;
for (uint32_t i = 0; i < memProps.memoryTypeCount; ++i) {
    if ((typeFilter & (1u << i)) &&
        (memProps.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) {
        needsExplicitFlush = !(memProps.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
        selectedTypeIndex = i;
        break;
    }
}

// At runtime, branch on the flag, not the vendor
if (needsExplicitFlush) {
    VkMappedMemoryRange range = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
    range.memory = allocation;
    range.offset = alignDown(offset, atomSize);
    range.size = alignUp(offset + size, atomSize) - range.offset;
    vkFlushMappedMemoryRanges(device, 1, &range); // after host write
    // or vkInvalidateMappedMemoryRanges(device, 1, &range); // before host read
}

Why This Works Across Vendors

• On discrete desktop GPUs, host-visible heaps are often uncached or write-combined, so flushes are effectively no-ops — but the calls are cheap.
• On integrated/mobile GPUs with cached host-visible heaps, missing flushes silently corrupt data.
• Branching on the HOST_COHERENT flag (queried at runtime) gives correct behavior everywhere with zero penalty on coherent platforms.

Verification Steps

1. Enable Vulkan validation layers; they flag missing or misaligned flush/invalidate.
2. Write a deterministic test: host writes a pattern, device copies to a readback buffer, host verifies — run with and without flush on a non-coherent type to observe the failure.
3. Log the selected memory type flags and nonCoherentAtomSize on each target device during QA.

One Diagnostic Detail Needed

Which GPU architectures (vendor + generation) are in your minimum supported hardware set? This determines whether a HOST_COHERENT type is universally available for your buffer usage, or if you must ship the explicit path for some devices.