gpu/command_buffer/service/dawn_caching_interface.cc

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "gpu/command_buffer/service/dawn_caching_interface.h"

#include <string>

#include "base/callback_helpers.h"
#include "base/memory/ptr_util.h"
#include "gpu/command_buffer/service/decoder_client.h"
#include "gpu/config/gpu_preferences.h"
#include "net/base/io_buffer.h"
#include "net/disk_cache/disk_cache.h"

namespace gpu::webgpu {

DawnCachingInterface::DawnCachingInterface(ScopedDiskCacheBackend backend,
                                           DecoderClient* decoder_client)
    : backend_(std::move(backend)), decoder_client_(decoder_client) {}

DawnCachingInterface::~DawnCachingInterface() = default;

size_t DawnCachingInterface::LoadData(const void* key,
                                      size_t key_size,
                                      void* value_out,
                                      size_t value_size) {
  if (backend() == nullptr) {
    return 0u;
  }
  std::string key_str(static_cast<const char*>(key), key_size);

  disk_cache::EntryResult entry_result = backend()->OpenOrCreateEntry(
      key_str, net::RequestPriority::DEFAULT_PRIORITY, base::DoNothing());
  if (entry_result.net_error() != net::OK) {
    return 0u;
  }
  disk_cache::ScopedEntryPtr entry(entry_result.ReleaseEntry());
  size_t size = entry->GetDataSize(0) > 0 ? entry->GetDataSize(0) : 0u;

  if (value_size == 0 && value_out == nullptr) {
    return size;
  }
  if (value_size != size) {
    return 0u;
  }

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::WrappedIOBuffer>(
          static_cast<const char*>(value_out));
  int status = entry->ReadData(0, 0, buffer.get(), size, base::DoNothing());
  return status > 0 ? size_t(status) : 0u;
}

void DawnCachingInterface::StoreData(const void* key,
                                     size_t key_size,
                                     const void* value,
                                     size_t value_size) {
  if (backend() == nullptr || value == nullptr || value_size <= 0) {
    return;
  }
  std::string key_str(static_cast<const char*>(key), key_size);

  disk_cache::EntryResult entry_result = backend()->OpenOrCreateEntry(
      key_str, net::RequestPriority::DEFAULT_PRIORITY, base::DoNothing());
  if (entry_result.net_error() != net::OK) {
    return;
  }
  disk_cache::ScopedEntryPtr entry(entry_result.ReleaseEntry());

  scoped_refptr<net::IOBuffer> buffer =
      base::MakeRefCounted<net::WrappedIOBuffer>(
          static_cast<const char*>(value));
  entry->WriteData(0, 0, buffer.get(), value_size, base::DoNothing(), false);

  // Send the cache entry to be stored on the host-side if applicable.
  if (decoder_client_) {
    std::string value_str(static_cast<const char*>(value), value_size);
    decoder_client_->CacheBlob(gpu::GpuDiskCacheType::kDawnWebGPU, key_str,
                               value_str);
  }
}

DawnCachingInterfaceFactory::DawnCachingInterfaceFactory(BackendFactory factory)
    : backend_factory_(factory) {}

DawnCachingInterfaceFactory::DawnCachingInterfaceFactory()
    : DawnCachingInterfaceFactory(base::BindRepeating(
          &DawnCachingInterfaceFactory::CreateDefaultInMemoryBackend)) {}

DawnCachingInterfaceFactory::~DawnCachingInterfaceFactory() = default;

ScopedDiskCacheBackend
DawnCachingInterfaceFactory::CreateDefaultInMemoryBackend() {
  disk_cache::BackendResult result = disk_cache::CreateCacheBackend(
      net::CacheType::MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT,
      /*file_operations=*/nullptr, base::FilePath(),
      /*max_bytes=*/GetDefaultGpuDiskCacheSize(),
      disk_cache::ResetHandling::kNeverReset,
      /*net_log=*/nullptr, base::DoNothing());

  // In-memory cache initialization should generally not fail. If it does,
  // currently just logging an error. All operations check that |backend_| is
  // valid so nothing bad will happen and we will fail silently with no cache
  // hits.
  if (result.net_error != net::OK) {
    LOG(WARNING) << "Unable to create an in-memory cache to back "
                    "DawnCachingInterface(s).";
    return base::MakeRefCounted<RefCountedDiskCacheBackend>(nullptr);
  }
  return base::MakeRefCounted<RefCountedDiskCacheBackend>(
      std::move(result.backend));
}

std::unique_ptr<DawnCachingInterface>
DawnCachingInterfaceFactory::CreateInstance(
    const gpu::GpuDiskCacheHandle& handle,
    DecoderClient* decoder_client) {
  DCHECK(gpu::GetHandleType(handle) == gpu::GpuDiskCacheType::kDawnWebGPU);

  if (const auto it = backends_.find(handle); it != backends_.end()) {
    return base::WrapUnique(
        new DawnCachingInterface(it->second, decoder_client));
  }

  ScopedDiskCacheBackend backend = backend_factory_.Run();
  if (backend->data.get() != nullptr) {
    backends_[handle] = backend;
  }
  return base::WrapUnique(
      new DawnCachingInterface(std::move(backend), decoder_client));
}

std::unique_ptr<DawnCachingInterface>
DawnCachingInterfaceFactory::CreateInstance() {
  return base::WrapUnique(new DawnCachingInterface(backend_factory_.Run()));
}

void DawnCachingInterfaceFactory::ReleaseHandle(
    const gpu::GpuDiskCacheHandle& handle) {
  DCHECK(gpu::GetHandleType(handle) == gpu::GpuDiskCacheType::kDawnWebGPU);
  backends_.erase(handle);
}

}  // namespace gpu::webgpu