A PCO can be used to create either a graphics (vkCreateGraphicsPipelines) or compute pipeline (vkCreateComputePipelines). Creating these pipelines with a PCO ensures the reusability of the pipeline objects. If the PCO does not contain a similar pipeline, then it creates a new one and adds it to its pool.

A PCO can be created using the vkCreatePipelineCache() API. Upon its successful creation, it returns a VkPipelineCache object. This API accepts four parameters, as described here:

VkResult vkCreatePipelineCache( 
    VkDevice                          device, 
    const VkPipelineCacheCreateInfo*  pCreateInfo, 
    const VkAllocationCallbacks*      pAllocator, 
    VkPipelineCache*                  pPipelineCache); 

The following are the various parameters accepted by the vkCreatePipelineCache() API:

The second parameter of the vkCreatePipelineCache() API is of the type VkPipelineCacheCreateInfo; this control structure contains the state/metadata information necessary to create and initialize the pipeline cache object. The following is the syntax of this structure:

typedef struct VkPipelineCacheCreateInfo { 
    VkStructureType               sType; 
    const void*                   pNext; 
    VkPipelineCacheCreateFlags    flags; 
    size_t                        initialDataSize; 
    const void*                   pInitialData; 
} VkPipelineCacheCreateInfo; 

Let's look at this structure's various fields:

Two pipeline caches can be merged together into one using the vkMergePipelineCaches() API. This API merges a destination pipeline cache into the source pipeline cache. It intakes four parameters. The first parameter device is the logical device for which the merging will be carried out. The number of source pipeline caches is specified by pSrcCaches with a count equal to srcCacheCount. The final merging cache is stored in the destination pipeline cache called dstCache.

The following is the syntax of this API:

VkResult vkMergePipelineCaches( 
         VkDevice                device, 
         VkPipelineCache         dstCache, 
         uint32_t                srcCacheCount, 
         const VkPipelineCache*  pSrcCaches); 

A pipeline cache object can save its information in the form of streams of bytes. This stored information can be reused in future, when an application reruns or is executed again. The pipeline cache data can be retrieved using the vkGetPipelineCacheData() API:

VkResult vkGetPipelineCacheData( 
         VkDevice                device, 
         VkPipelineCache         pipelineCache, 
         size_t*                 dataSize, 
         void*                   data); 

The following table describes each parameter of this API:

The stored PCO information can be reused to preinitialize and populate the pipeline cache objects when the application starts. The compilation results may depend on the vendor and other device details. In order to ensure the application is compatible with the pipeline cache data, the header information can be used.

The retrieved data contains a header and a payload. The header provides the necessary information about the written data to ensure there is compatibility when an application runs the next time. The following diagram shows the format of the stored pipeline cache object:

The header consists of five fields, which may change in line with the specification. The header size is not fixed as per the specification but is read as the first four bytes from the data. This byte information encodes the length of the entire pipeline cache object's retrieved data header (in bytes), including each and every field in the header.

The following table specifies these fields' specification along with their size in bytes:

The PCO is implemented in VulkanPipeline.cpp in the createPipelinceCache() function. VkPipelineCacheCreateInfo is initialized and passed to the vkCreatePipelineCache() API. The initialDataSize is 0 and pInitialData is NULL, as there is no old, retrievable PCO data to be used in the initialization of the created PCO:

void VulkanPipeline::createPipelineCache() 
{ 
    VkResult result; 
    VkPipelineCacheCreateInfo pipelineCacheInfo; 
    pipelineCacheInfo.sType            = VK_STRUCTURE_TYPE_PIPELINE 
                                       _CACHE_CREATE_INFO; 
    pipelineCacheInfo.pNext            = NULL; 
    pipelineCacheInfo.initialDataSize  = 0; 
    pipelineCacheInfo.pInitialData     = NULL; 
    pipelineCacheInfo.flags            = 0; 
 
    // Create the pipeline cache using VkPipelineCacheCreateInfo 
    result = vkCreatePipelineCache(deviceObj->device,  
               &pipelineCacheInfo, NULL, &pipelineCache); 
    assert(result == VK_SUCCESS); 
}