host: make system blob memory work on macOS

[utzcoz]

Two host fixes for running the guest Vulkan driver through kumquat on macOS.
Both only take effect with SystemBlob enabled.

• vulkan: add a guest only device local memory type when the host reports a
  single host visible unified type. Metal cannot bind a tiled image to an
  imported host pointer; this gives images ordinary device memory. Unit test
  added.

• base: put the pid in the shared memory name and unlink it on creation, so a
  killed server does not leave objects that make the next ftruncate fail.

Tested with bazel test //host/vulkan:gfxstream_emulatedphysicalmemory_tests,
and vulkaninfo, vkcube and a dEQP-VK smoke run on kosmickrisp and MoltenVK.

[utzcoz]

Required by https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/44259.

[utzcoz]

Friendly ping @gurchetansingh @jmacnak for reviewing.

[gurchetansingh]

@jmacnak knows this code well, would be the right person to review

[jmacnak]

One thread about readability but overall logic LGTM

[jmacnak]

Now that we are inserting 2 emulated guest memory types and the indicies and offsets are getting a little more complicated to read and reason about, I wonder if we could replace the index mappings with something a bit more readable.

struct EmulatedGuestMemoryType {
   uint32_t hostMemoryTypeIndex = kInvalidMemoryTypeIndex;

   // This memory type is reserved for controlling the
   // memory properties of AHBs with the 
   // VulkanUseDedicatedAhbMemoryType feature.
   bool isReservedForAhbAllocations = false;
   
   // This memory type is reserved for optimally tiled
   // images on Apple when used with system blobs where
   // the host must not try to 
   bool isReservedForAppleSystemBlobAllocations = false;

   // The memory properties reported to the guest.
   VkMemoryType memoryType;
};
std::vector<EmulatedGuestMemoryType> mGuestMemoryTypes;

struct HostMemoryType {
   // The corresponding guest memory index.
   uint32_t guestMemoryTypeIndex = kInvalidMemoryTypeIndex;

   // The unaltered host memory properties.
   VkMemoryType memoryType;
}
std::vector<HostMemoryType> mHostMemoryTypes;

Then, inside EmulatedPhysicalDeviceMemoryProperties's constructor, we have something like

mHostMemoryProperties = hostMemoryProperties;

// Start with the original host properties
mGuestMemoryTypes.reserve(hostMemoryProperties. memoryTypeCount);
for ( <each host memory type> ) {
    mGuestMemoryTypes.push_back(EmulatedGuestMemoryType{
   .hostMemoryTypeIndex = index,
   .memoryType = hostMemoryProperties.memoryType[index]
};
}

<apply transformations on mGuestMemoryTypes>

<insert a EmulatedGuestMemoryType for apple if needed>

<insert a EmulatedGuestMemoryType for AHBs if needed>

where we are just working with objects and we can use

mGuestMemoryTypes.insert(mGuestMemoryTypes.begin() + <desired index>);

with a helper function that is self documenting:

uint32_t FindIndexForNewMemoryType(const std::vector<EmulatedGuestMemoryType>& memoryTypes) {
  // Per https://docs.vulkan.org/refpages/latest/refpages/source/VkPhysicalDeviceMemoryProperties.html, 
  //  memory types must be ordered so that earlier memory
  //  types have a strict subset of flags of later types.

 ...
}

The very end of the constructor can finally generate the flattened mGuestMemoryProperties.

WDYT?

[utzcoz]

Done. Guest memory types are now a vector of EmulatedGuestMemoryType. The Apple type is inserted with findIndexForNewMemoryType() and the vector is flattened into mGuestMemoryProperties afterwards.