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
Public Member Functions inherited from GrContextOptions::PersistentCache
virtual void	store (const SkData &key, const SkData &data, const SkString &)

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"

Private Member Functions
void	store (const SkData &key, const SkData &data) override

Friends
class	testing::ShellTest

Additional Inherited Members
Protected Member Functions inherited from GrContextOptions::PersistentCache
	PersistentCache ()=default
	PersistentCache (const PersistentCache &)=delete
PersistentCache &	operator= (const PersistentCache &)=delete

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 30 of file persistent_cache.h.

Constructor & Destructor Documentation

~PersistentCache()

flutter::PersistentCache::~PersistentCache ( )

overridevirtualdefault

Reimplemented from GrContextOptions::PersistentCache.

Member Function Documentation

AddWorkerTaskRunner()

void flutter::PersistentCache::AddWorkerTaskRunner

(

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

task_runner

)

Definition at line 444 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 122 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 378 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;
}

cache_sksl()

static bool flutter::PersistentCache::cache_sksl ( )

inlinestatic

Definition at line 126 of file persistent_cache.h.

{ return cache_sksl_; }

DumpSkp()

void flutter::PersistentCache::DumpSkp

(

const SkData &

data

)

Definition at line 426 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));
}

GetCacheForProcess()

PersistentCache * flutter::PersistentCache::GetCacheForProcess ( )

static

Definition at line 63 of file persistent_cache.cc.

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

GetSkpsFromAssetManager()

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

(

)

const

Definition at line 476 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");
}

IsDumpingSkp()

bool flutter::PersistentCache::IsDumpingSkp ( ) const

inline

Definition at line 83 of file persistent_cache.h.

{ return is_dumping_skp_; }

load()

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

overridevirtual

Returns the data for the key if it exists in the cache, otherwise returns null.

Implements GrContextOptions::PersistentCache.

Definition at line 330 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;
}

LoadSkSLs()

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

(

)

const

Load all the SkSL shader caches in the right directory.

Definition at line 221 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;
}

MarkStrategySet()

static void flutter::PersistentCache::MarkStrategySet ( )

inlinestatic

Definition at line 130 of file persistent_cache.h.

{ strategy_set_ = true; }

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 194 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;
}

Purge()

bool flutter::PersistentCache::Purge

(

)

Definition at line 81 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();
}

RemoveWorkerTaskRunner()

void flutter::PersistentCache::RemoveWorkerTaskRunner

(

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

task_runner

)

Definition at line 450 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 71 of file persistent_cache.cc.

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

ResetStoredNewShaders()

void flutter::PersistentCache::ResetStoredNewShaders ( )

inline

Definition at line 81 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 470 of file persistent_cache.cc.

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

SetCacheDirectoryPath()

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

static

Definition at line 77 of file persistent_cache.cc.

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

SetCacheSkSL()

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

static

Definition at line 54 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;
}

SetIsDumpingSkp()

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

inline

Definition at line 84 of file persistent_cache.h.

{ is_dumping_skp_ = value; }

SkKeyToFilePath()

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

static

Definition at line 36 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);
}

store()

void flutter::PersistentCache::store ( const SkData &  key, const SkData &  data  )

overrideprivatevirtual

Reimplemented from GrContextOptions::PersistentCache.

Definition at line 399 of file persistent_cache.cc.

                                                                 {
  stored_new_shaders_ = true;
 
  if (is_read_only_) {
    return;
  }
 
  if (!IsValid()) {
    return;
  }
 
  auto file_name = SkKeyToFilePath(key);
 
  if (file_name.empty()) {
    return;
  }
 
  std::unique_ptr<fml::MallocMapping> mapping = BuildCacheObject(key, data);
  if (!mapping) {
    return;
  }
 
  PersistentCacheStore(GetWorkerTaskRunner(),
                       cache_sksl_ ? sksl_cache_directory_ : cache_directory_,
                       std::move(file_name), std::move(mapping));
}

StoredNewShaders()

bool flutter::PersistentCache::StoredNewShaders ( ) const

inline

Definition at line 80 of file persistent_cache.h.

{ return stored_new_shaders_; }

Friends And Related Symbol Documentation

testing::ShellTest

friend class testing::ShellTest

friend

Definition at line 175 of file persistent_cache.h.

Member Data Documentation

gIsReadOnly

bool flutter::PersistentCache::gIsReadOnly = false

static

Definition at line 37 of file persistent_cache.h.

kAssetFileName

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

staticconstexpr

Definition at line 133 of file persistent_cache.h.

kSkSLSubdirName

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

staticconstexpr

Definition at line 132 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