flutter::PersistentCache Class Reference

#include <persistent_cache.h>

Inheritance diagram for flutter::PersistentCache:

Classes
struct	CacheObjectHeader
struct	SkSLCache

Public Member Functions
	~PersistentCache () override
void	AddWorkerTaskRunner (const fml::RefPtr< fml::TaskRunner > &task_runner)
void	RemoveWorkerTaskRunner (const fml::RefPtr< fml::TaskRunner > &task_runner)
bool	StoredNewShaders () const
void	ResetStoredNewShaders ()
void	DumpSkp (const SkData &data)
bool	IsDumpingSkp () const
void	SetIsDumpingSkp (bool value)
bool	Purge ()
sk_sp< SkData >	load (const SkData &key) override
std::vector< SkSLCache >	LoadSkSLs () const
	Load all the SkSL shader caches in the right directory.
size_t	PrecompileKnownSkSLs (GrDirectContext *context) const
	Precompile SkSLs packaged with the application and gathered during previous runs in the given context.
std::vector< std::unique_ptr< fml::Mapping > >	GetSkpsFromAssetManager () const

Static Public Member Functions
static PersistentCache *	GetCacheForProcess ()
static void	ResetCacheForProcess ()
static void	SetCacheDirectoryPath (std::string path)
static std::string	SkKeyToFilePath (const SkData &key)
static std::unique_ptr< fml::MallocMapping >	BuildCacheObject (const SkData &key, const SkData &data)
static void	SetAssetManager (std::shared_ptr< AssetManager > value)
static std::shared_ptr< AssetManager >	asset_manager ()
static bool	cache_sksl ()
static void	SetCacheSkSL (bool value)
static void	MarkStrategySet ()

Static Public Attributes
static bool	gIsReadOnly = false
static constexpr char	kSkSLSubdirName [] = "sksl"
static constexpr char	kAssetFileName [] = "io.flutter.shaders.json"

Friends
class	testing::ShellTest

Detailed Description

A cache of SkData that gets stored to disk.

This is mainly used for Shaders but is also written to by Dart. It is thread-safe for reading and writing from multiple threads.

Definition at line 32 of file persistent_cache.h.

Constructor & Destructor Documentation

~PersistentCache()

flutter::PersistentCache::~PersistentCache ( )

overridedefault

Member Function Documentation

AddWorkerTaskRunner()

void flutter::PersistentCache::AddWorkerTaskRunner

(

const fml::RefPtr< fml::TaskRunner > &

task_runner

)

Definition at line 446 of file persistent_cache.cc.

                                                 {
  std::scoped_lock lock(worker_task_runners_mutex_);
  worker_task_runners_.insert(task_runner);
}

asset_manager()

static std::shared_ptr< AssetManager > flutter::PersistentCache::asset_manager ( )

inlinestatic

Definition at line 124 of file persistent_cache.h.

                                                     {
    return asset_manager_;
  }

BuildCacheObject()

std::unique_ptr< fml::MallocMapping > flutter::PersistentCache::BuildCacheObject ( const SkData &  key, const SkData &  data  )

static

Definition at line 380 of file persistent_cache.cc.

                        {
  size_t total_size = sizeof(CacheObjectHeader) + key.size() + data.size();
  uint8_t* mapping_buf = reinterpret_cast<uint8_t*>(malloc(total_size));
  if (!mapping_buf) {
    return nullptr;
  }
  auto mapping = std::make_unique<fml::MallocMapping>(mapping_buf, total_size);
 
  CacheObjectHeader header(key.size());
  memcpy(mapping_buf, &header, sizeof(CacheObjectHeader));
  mapping_buf += sizeof(CacheObjectHeader);
  memcpy(mapping_buf, key.data(), key.size());
  mapping_buf += key.size();
  memcpy(mapping_buf, data.data(), data.size());
 
  return mapping;
}

References flutter::data, and key.

cache_sksl()

static bool flutter::PersistentCache::cache_sksl ( )

inlinestatic

Definition at line 128 of file persistent_cache.h.

{ return cache_sksl_; }

Referenced by flutter::MakeDefaultContextOptions().

DumpSkp()

void flutter::PersistentCache::DumpSkp

(

const SkData &

data

)

Definition at line 428 of file persistent_cache.cc.

                                                {
  if (is_read_only_ || !IsValid()) {
    FML_LOG(ERROR) << "Could not dump SKP from read-only or invalid persistent "
                      "cache.";
    return;
  }
 
  std::stringstream name_stream;
  auto ticks = fml::TimePoint::Now().ToEpochDelta().ToNanoseconds();
  name_stream << "shader_dump_" << std::to_string(ticks) << ".skp";
  std::string file_name = name_stream.str();
  FML_LOG(INFO) << "Dumping " << file_name;
  auto mapping = std::make_unique<fml::DataMapping>(
      std::vector<uint8_t>{data.bytes(), data.bytes() + data.size()});
  PersistentCacheStore(GetWorkerTaskRunner(), cache_directory_,
                       std::move(file_name), std::move(mapping));
}

References flutter::data, FML_LOG, fml::TimePoint::Now(), flutter::PersistentCacheStore(), fml::TimePoint::ToEpochDelta(), and fml::TimeDelta::ToNanoseconds().

GetCacheForProcess()

PersistentCache * flutter::PersistentCache::GetCacheForProcess ( )

static

Definition at line 65 of file persistent_cache.cc.

                                                     {
  std::scoped_lock lock(instance_mutex_);
  if (gPersistentCache == nullptr) {
    gPersistentCache.reset(new PersistentCache(gIsReadOnly));
  }
  return gPersistentCache.get();
}

References gIsReadOnly.

Referenced by flutter::testing::CheckTwoSkSLsAreLoaded(), flutter::Shell::GetSettings(), flutter::MakeDefaultContextOptions(), flutter::GPUSurfaceGLSkia::MakeGLContext(), flutter::testing::ResetAssetManager(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

GetSkpsFromAssetManager()

std::vector< std::unique_ptr< fml::Mapping > > flutter::PersistentCache::GetSkpsFromAssetManager

(

)

const

Definition at line 478 of file persistent_cache.cc.

                                               {
  if (!asset_manager_) {
    FML_LOG(ERROR)
        << "PersistentCache::GetSkpsFromAssetManager: Asset manager not set!";
    return std::vector<std::unique_ptr<fml::Mapping>>();
  }
  return asset_manager_->GetAsMappings(".*\\.skp$", "shaders");
}

References FML_LOG.

IsDumpingSkp()

bool flutter::PersistentCache::IsDumpingSkp ( ) const

inline

Definition at line 85 of file persistent_cache.h.

{ return is_dumping_skp_; }

load()

sk_sp< SkData > flutter::PersistentCache::load ( const SkData &  key )

override

Definition at line 332 of file persistent_cache.cc.

                                                     {
  TRACE_EVENT0("flutter", "PersistentCacheLoad");
  if (!IsValid()) {
    return nullptr;
  }
  auto file_name = SkKeyToFilePath(key);
  if (file_name.empty()) {
    return nullptr;
  }
  auto result =
      PersistentCache::LoadFile(*cache_directory_, file_name, false).value;
  if (result != nullptr) {
    TRACE_EVENT0("flutter", "PersistentCacheLoadHit");
  }
  return result;
}

References key, SkKeyToFilePath(), and TRACE_EVENT0.

LoadSkSLs()

std::vector< PersistentCache::SkSLCache > flutter::PersistentCache::LoadSkSLs

(

)

const

Load all the SkSL shader caches in the right directory.

Definition at line 223 of file persistent_cache.cc.

                                                                     {
  TRACE_EVENT0("flutter", "PersistentCache::LoadSkSLs");
  std::vector<PersistentCache::SkSLCache> result;
  fml::FileVisitor visitor = [&result](const fml::UniqueFD& directory,
                                       const std::string& filename) {
    SkSLCache cache = LoadFile(directory, filename, true);
    if (cache.key != nullptr && cache.value != nullptr) {
      result.push_back(cache);
    } else {
      FML_LOG(ERROR) << "Failed to load: " << filename;
    }
    return true;
  };
 
  // Only visit sksl_cache_directory_ if this persistent cache is valid.
  // However, we'd like to continue visit the asset dir even if this persistent
  // cache is invalid.
  if (IsValid()) {
    // In case `rewinddir` doesn't work reliably, load SkSLs from a freshly
    // opened directory (https://github.com/flutter/flutter/issues/65258).
    fml::UniqueFD fresh_dir =
        fml::OpenDirectoryReadOnly(*cache_directory_, kSkSLSubdirName);
    if (fresh_dir.is_valid()) {
      fml::VisitFiles(fresh_dir, visitor);
    }
  }
 
  std::unique_ptr<fml::Mapping> mapping = nullptr;
  if (asset_manager_ != nullptr) {
    mapping = asset_manager_->GetAsMapping(kAssetFileName);
  }
  if (mapping == nullptr) {
    FML_LOG(INFO) << "No sksl asset found.";
  } else {
    FML_LOG(INFO) << "Found sksl asset. Loading SkSLs from it...";
    rapidjson::Document json_doc;
    rapidjson::ParseResult parse_result =
        json_doc.Parse(reinterpret_cast<const char*>(mapping->GetMapping()),
                       mapping->GetSize());
    if (parse_result.IsError()) {
      FML_LOG(ERROR) << "Failed to parse json file: " << kAssetFileName;
    } else {
      for (auto& item : json_doc["data"].GetObject()) {
        sk_sp<SkData> key = ParseBase32(item.name.GetString());
        sk_sp<SkData> sksl = ParseBase64(item.value.GetString());
        if (key != nullptr && sksl != nullptr) {
          result.push_back({key, sksl});
        } else {
          FML_LOG(ERROR) << "Failed to load: " << item.name.GetString();
        }
      }
    }
  }
 
  return result;
}

References FML_LOG, fml::UniqueObject< T, Traits >::is_valid(), flutter::PersistentCache::SkSLCache::key, key, fml::OpenDirectoryReadOnly(), flutter::ParseBase32(), flutter::ParseBase64(), TRACE_EVENT0, flutter::PersistentCache::SkSLCache::value, and fml::VisitFiles().

Referenced by flutter::testing::CheckTwoSkSLsAreLoaded(), and flutter::testing::TEST_F().

MarkStrategySet()

static void flutter::PersistentCache::MarkStrategySet ( )

inlinestatic

Definition at line 132 of file persistent_cache.h.

{ strategy_set_ = true; }

Referenced by flutter::MakeDefaultContextOptions().

PrecompileKnownSkSLs()

size_t flutter::PersistentCache::PrecompileKnownSkSLs

(

GrDirectContext *

context

)

const

Precompile SkSLs packaged with the application and gathered during previous runs in the given context.

Warning

The context must be the rendering context. This context may be destroyed during application suspension and subsequently recreated. The SkSLs must be precompiled again in the new context.

Parameters

context

The rendering context to precompile shaders in.

Returns

The number of SkSLs precompiled.

Definition at line 196 of file persistent_cache.cc.

                                                                           {
  // clang-tidy has trouble reasoning about some of the complicated array and
  // pointer-arithmetic code in rapidjson.
  // NOLINTNEXTLINE(clang-analyzer-cplusplus.PlacementNew)
  auto known_sksls = LoadSkSLs();
  // A trace must be present even if no precompilations have been completed.
  FML_TRACE_EVENT("flutter", "PersistentCache::PrecompileKnownSkSLs", "count",
                  known_sksls.size());
 
  if (context == nullptr) {
    return 0;
  }
 
  size_t precompiled_count = 0;
  for (const auto& sksl : known_sksls) {
    TRACE_EVENT0("flutter", "PrecompilingSkSL");
    if (context->precompileShader(*sksl.key, *sksl.value)) {
      precompiled_count++;
    }
  }
 
  FML_TRACE_COUNTER("flutter", "PersistentCache::PrecompiledSkSLs",
                    reinterpret_cast<int64_t>(this),  // Trace Counter ID
                    "Successful", precompiled_count);
  return precompiled_count;
}

References FML_TRACE_COUNTER, FML_TRACE_EVENT, and TRACE_EVENT0.

Referenced by flutter::GPUSurfaceGLSkia::MakeGLContext().

Purge()

bool flutter::PersistentCache::Purge

(

)

Definition at line 83 of file persistent_cache.cc.

                            {
  // Make sure that this is called after the worker task runner setup so all the
  // file system modifications would happen on that single thread to avoid
  // racing.
  FML_CHECK(GetWorkerTaskRunner());
 
  std::promise<bool> removed;
  GetWorkerTaskRunner()->PostTask([&removed,
                                   cache_directory = cache_directory_]() {
    if (cache_directory->is_valid()) {
      // Only remove files but not directories.
      FML_LOG(INFO) << "Purge persistent cache.";
      fml::FileVisitor delete_file = [](const fml::UniqueFD& directory,
                                        const std::string& filename) {
        // Do not delete directories. Return true to continue with other files.
        if (fml::IsDirectory(directory, filename.c_str())) {
          return true;
        }
        return fml::UnlinkFile(directory, filename.c_str());
      };
      removed.set_value(VisitFilesRecursively(*cache_directory, delete_file));
    } else {
      removed.set_value(false);
    }
  });
  return removed.get_future().get();
}

References FML_CHECK, and fml::TaskRunner::PostTask().

Referenced by flutter::Shell::GetSettings().

RemoveWorkerTaskRunner()

void flutter::PersistentCache::RemoveWorkerTaskRunner

(

const fml::RefPtr< fml::TaskRunner > &

task_runner

)

Definition at line 452 of file persistent_cache.cc.

                                                 {
  std::scoped_lock lock(worker_task_runners_mutex_);
  auto found = worker_task_runners_.find(task_runner);
  if (found != worker_task_runners_.end()) {
    worker_task_runners_.erase(found);
  }
}

ResetCacheForProcess()

void flutter::PersistentCache::ResetCacheForProcess ( )

static

Definition at line 73 of file persistent_cache.cc.

                                           {
  std::scoped_lock lock(instance_mutex_);
  gPersistentCache.reset(new PersistentCache(gIsReadOnly));
  strategy_set_ = false;
}

References gIsReadOnly.

Referenced by flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

ResetStoredNewShaders()

void flutter::PersistentCache::ResetStoredNewShaders ( )

inline

Definition at line 83 of file persistent_cache.h.

{ stored_new_shaders_ = false; }

SetAssetManager()

void flutter::PersistentCache::SetAssetManager ( std::shared_ptr< AssetManager >  value )

static

Set the asset manager from which PersistentCache can load SkLSs. A nullptr can be provided to clear the asset manager.

Definition at line 472 of file persistent_cache.cc.

                                                                       {
  TRACE_EVENT_INSTANT0("flutter", "PersistentCache::SetAssetManager");
  asset_manager_ = std::move(value);
}

References TRACE_EVENT_INSTANT0, and value.

Referenced by flutter::testing::ResetAssetManager(), flutter::RunConfiguration::RunConfiguration(), and flutter::RunConfiguration::RunConfiguration().

SetCacheDirectoryPath()

void flutter::PersistentCache::SetCacheDirectoryPath ( std::string  path )

static

Definition at line 79 of file persistent_cache.cc.

                                                          {
  cache_base_path_ = std::move(path);
}

References flutter::path.

Referenced by FlutterEngineInitialize(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

SetCacheSkSL()

void flutter::PersistentCache::SetCacheSkSL ( bool  value )

static

Definition at line 56 of file persistent_cache.cc.

                                             {
  if (strategy_set_ && value != cache_sksl_) {
    FML_LOG(ERROR) << "Cache SkSL can only be set before the "
                      "GrContextOptions::fShaderCacheStrategy is set.";
    return;
  }
  cache_sksl_ = value;
}

References FML_LOG, and value.

SetIsDumpingSkp()

void flutter::PersistentCache::SetIsDumpingSkp ( bool  value )

inline

Definition at line 86 of file persistent_cache.h.

{ is_dumping_skp_ = value; }

References value.

SkKeyToFilePath()

std::string flutter::PersistentCache::SkKeyToFilePath ( const SkData &  key )

static

Definition at line 38 of file persistent_cache.cc.

                                                            {
  if (key.data() == nullptr || key.size() == 0) {
    return "";
  }
 
  uint8_t sha_digest[SHA_DIGEST_LENGTH];
  SHA1(static_cast<const uint8_t*>(key.data()), key.size(), sha_digest);
 
  std::string_view view(reinterpret_cast<const char*>(sha_digest),
                        SHA_DIGEST_LENGTH);
  return fml::HexEncode(view);
}

References fml::HexEncode(), key, and view.

Referenced by load(), and flutter::testing::TEST_F().

StoredNewShaders()

bool flutter::PersistentCache::StoredNewShaders ( ) const

inline

Definition at line 82 of file persistent_cache.h.

{ return stored_new_shaders_; }

Friends And Related Symbol Documentation

testing::ShellTest

friend class testing::ShellTest

friend

Definition at line 177 of file persistent_cache.h.

Member Data Documentation

gIsReadOnly

bool flutter::PersistentCache::gIsReadOnly = false

static

Definition at line 39 of file persistent_cache.h.

Referenced by FlutterEngineInitialize(), GetCacheForProcess(), and ResetCacheForProcess().

kAssetFileName

constexpr char flutter::PersistentCache::kAssetFileName[] = "io.flutter.shaders.json"

staticconstexpr

Definition at line 135 of file persistent_cache.h.

Referenced by flutter::testing::TEST_F().

kSkSLSubdirName

constexpr char flutter::PersistentCache::kSkSLSubdirName[] = "sksl"

staticconstexpr

Definition at line 134 of file persistent_cache.h.

---

The documentation for this class was generated from the following files:

• common/graphics/persistent_cache.h
• common/graphics/persistent_cache.cc