[Bf-blender-cvs] [610619c2031] master: Merge branch 'blender-v3.2-release'

[Brecht Van Lommel]

Commit: 610619c2031056330f174bcee590c363cb6b45fc
Author: Brecht Van Lommel
Date:   Tue May 31 17:35:16 2022 +0200
Branches: master
https://developer.blender.org/rB610619c2031056330f174bcee590c363cb6b45fc

Merge branch 'blender-v3.2-release'

===================================================================



===================================================================

diff --cc intern/cycles/device/metal/kernel.mm
index 304efc813ec,a3c4839c21f..fec4cd80466
--- a/intern/cycles/device/metal/kernel.mm
+++ b/intern/cycles/device/metal/kernel.mm
@@@ -29,112 -28,10 +29,113 @@@ const char *kernel_type_as_string(int k
    return "";
  }
  
 -MetalDeviceKernel::~MetalDeviceKernel()
 +bool kernel_has_intersection(DeviceKernel device_kernel)
  {
 -  for (int i = 0; i < PSO_NUM; i++) {
 -    pso[i].release();
 +  return (device_kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST ||
 +          device_kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW ||
 +          device_kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE ||
 +          device_kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK ||
-           device_kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE);
++          device_kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE ||
++          device_kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_MNEE);
 +}
 +
 +struct ShaderCache {
 +  ShaderCache(id<MTLDevice> _mtlDevice) : mtlDevice(_mtlDevice)
 +  {
 +  }
 +  ~ShaderCache();
 +
 +  /* Get the fastest available pipeline for the specified kernel. */
 +  MetalKernelPipeline *get_best_pipeline(DeviceKernel kernel, const MetalDevice *device);
 +
 +  /* Non-blocking request for a kernel, optionally specialized to the scene being rendered by
 +   * device. */
 +  void load_kernel(DeviceKernel kernel, MetalDevice *device, bool scene_specialized);
 +
 +  void wait_for_all();
 +
 + private:
 +  friend ShaderCache *get_shader_cache(id<MTLDevice> mtlDevice);
 +
 +  void compile_thread_func(int thread_index);
 +
 +  using PipelineCollection = std::vector<unique_ptr<MetalKernelPipeline>>;
 +
 +  struct PipelineRequest {
 +    MetalKernelPipeline *pipeline = nullptr;
 +    std::function<void(MetalKernelPipeline *)> completionHandler;
 +  };
 +
 +  std::mutex cache_mutex;
 +
 +  PipelineCollection pipelines[DEVICE_KERNEL_NUM];
 +  id<MTLDevice> mtlDevice;
 +
 +  bool running = false;
 +  std::condition_variable cond_var;
 +  std::deque<PipelineRequest> request_queue;
 +  std::vector<std::thread> compile_threads;
 +  std::atomic_int incomplete_requests = 0;
 +};
 +
 +std::mutex g_shaderCacheMutex;
 +std::map<id<MTLDevice>, unique_ptr<ShaderCache>> g_shaderCache;
 +
 +ShaderCache *get_shader_cache(id<MTLDevice> mtlDevice)
 +{
 +  thread_scoped_lock lock(g_shaderCacheMutex);
 +  auto it = g_shaderCache.find(mtlDevice);
 +  if (it != g_shaderCache.end()) {
 +    return it->second.get();
 +  }
 +
 +  g_shaderCache[mtlDevice] = make_unique<ShaderCache>(mtlDevice);
 +  return g_shaderCache[mtlDevice].get();
 +}
 +
 +ShaderCache::~ShaderCache()
 +{
 +  metal_printf("ShaderCache shutting down with incomplete_requests = %d\n",
 +               int(incomplete_requests));
 +
 +  running = false;
 +  cond_var.notify_all();
 +  for (auto &thread : compile_threads) {
 +    thread.join();
 +  }
 +}
 +
 +void ShaderCache::wait_for_all()
 +{
 +  while (incomplete_requests > 0) {
 +    std::this_thread::sleep_for(std::chrono::milliseconds(100));
 +  }
 +}
 +
 +void ShaderCache::compile_thread_func(int thread_index)
 +{
 +  while (1) {
 +
 +    /* wait for / acquire next request */
 +    PipelineRequest request;
 +    {
 +      thread_scoped_lock lock(cache_mutex);
 +      cond_var.wait(lock, [&] { return !running || !request_queue.empty(); });
 +      if (!running) {
 +        break;
 +      }
 +
 +      if (!request_queue.empty()) {
 +        request = request_queue.front();
 +        request_queue.pop_front();
 +      }
 +    }
 +
 +    /* service request */
 +    if (request.pipeline) {
 +      request.pipeline->compile();
 +      incomplete_requests--;
 +    }
    }
  }