blob: d279a92fa777d18b3b66804787d3caaaa699d9d2 [file] [log] [blame]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "software_surface_producer.h"
#include <lib/fdio/directory.h>
#include <lib/zx/process.h>
#include <algorithm> // For std::remove_if
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "flutter/fml/logging.h"
#include "flutter/fml/trace_event.h"
namespace flutter_runner {
namespace {
std::string GetCurrentProcessName() {
char name[ZX_MAX_NAME_LEN];
zx_status_t status =
zx::process::self()->get_property(ZX_PROP_NAME, name, sizeof(name));
if (status != ZX_OK) {
FML_LOG(ERROR) << "Failed to get process name for sysmem; using \"\".";
return std::string();
}
return std::string(name);
}
zx_koid_t GetCurrentProcessId() {
zx_info_handle_basic_t info;
zx_status_t status = zx::process::self()->get_info(
ZX_INFO_HANDLE_BASIC, &info, sizeof(info), /*actual_count*/ nullptr,
/*avail_count*/ nullptr);
if (status != ZX_OK) {
FML_LOG(ERROR) << "Failed to get process ID for sysmem; using 0.";
return ZX_KOID_INVALID;
}
return info.koid;
}
} // namespace
SoftwareSurfaceProducer::SoftwareSurfaceProducer() {
zx_status_t status = fdio_service_connect(
"/svc/fuchsia.sysmem.Allocator",
sysmem_allocator_.NewRequest().TakeChannel().release());
sysmem_allocator_->SetDebugClientInfo(GetCurrentProcessName(),
GetCurrentProcessId());
FML_DCHECK(status == ZX_OK);
status = fdio_service_connect(
"/svc/fuchsia.ui.composition.Allocator",
flatland_allocator_.NewRequest().TakeChannel().release());
FML_DCHECK(status == ZX_OK);
valid_ = true;
}
SoftwareSurfaceProducer::~SoftwareSurfaceProducer() = default;
std::unique_ptr<SurfaceProducerSurface>
SoftwareSurfaceProducer::ProduceOffscreenSurface(const SkISize& size) {
FML_CHECK(valid_);
return CreateSurface(size);
}
std::unique_ptr<SurfaceProducerSurface> SoftwareSurfaceProducer::ProduceSurface(
const SkISize& size) {
TRACE_EVENT2("flutter", "SoftwareSurfacePool::ProduceSurface", "width",
size.width(), "height", size.height());
FML_CHECK(valid_);
std::unique_ptr<SurfaceProducerSurface> surface;
auto exact_match_it =
std::find_if(available_surfaces_.begin(), available_surfaces_.end(),
[&size](const auto& surface) {
return surface->IsValid() && surface->GetSize() == size;
});
if (exact_match_it != available_surfaces_.end()) {
TRACE_EVENT_INSTANT0("flutter", "Exact match found");
surface = std::move(*exact_match_it);
available_surfaces_.erase(exact_match_it);
} else {
surface = CreateSurface(size);
}
if (surface == nullptr) {
FML_LOG(ERROR) << "Could not acquire surface.";
return nullptr;
}
if (!surface->FlushSessionAcquireAndReleaseEvents()) {
FML_LOG(ERROR) << "Could not flush acquire/release events for buffer.";
return nullptr;
}
return surface;
}
void SoftwareSurfaceProducer::SubmitSurfaces(
std::vector<std::unique_ptr<SurfaceProducerSurface>> surfaces) {
TRACE_EVENT0("flutter", "SoftwareSurfaceProducer::SubmitSurfaces");
// Submit surface
for (auto& surface : surfaces) {
SubmitSurface(std::move(surface));
}
// Buffer management.
AgeAndCollectOldBuffers();
}
void SoftwareSurfaceProducer::SubmitSurface(
std::unique_ptr<SurfaceProducerSurface> surface) {
TRACE_EVENT0("flutter", "SoftwareSurfacePool::SubmitSurface");
FML_CHECK(valid_);
// This cast is safe because |SoftwareSurface| is the only implementation of
// |SurfaceProducerSurface| for Flutter on Fuchsia. Additionally, it is
// required, because we need to access |SoftwareSurface| specific information
// of the surface (such as the amount of memory it contains).
auto software_surface = std::unique_ptr<SoftwareSurface>(
static_cast<SoftwareSurface*>(surface.release()));
if (!software_surface) {
return;
}
uintptr_t surface_key = reinterpret_cast<uintptr_t>(software_surface.get());
auto insert_iterator = pending_surfaces_.insert(std::make_pair(
surface_key, // key
std::move(software_surface) // value
));
if (insert_iterator.second) {
insert_iterator.first->second->SignalWritesFinished(std::bind(
&SoftwareSurfaceProducer::RecyclePendingSurface, this, surface_key));
}
}
std::unique_ptr<SoftwareSurface> SoftwareSurfaceProducer::CreateSurface(
const SkISize& size) {
TRACE_EVENT2("flutter", "SoftwareSurfacePool::CreateSurface", "width",
size.width(), "height", size.height());
auto surface = std::make_unique<SoftwareSurface>(sysmem_allocator_,
flatland_allocator_, size);
if (!surface->IsValid()) {
FML_LOG(ERROR) << "Created surface is invalid.";
return nullptr;
}
trace_surfaces_created_++;
return surface;
}
void SoftwareSurfaceProducer::RecycleSurface(
std::unique_ptr<SoftwareSurface> surface) {
// The surface may have become invalid (for example if the fences could
// not be reset).
if (!surface->IsValid()) {
FML_LOG(ERROR) << "Attempted to recycle invalid surface.";
return;
}
TRACE_EVENT0("flutter", "SoftwareSurfacePool::RecycleSurface");
// Recycle the buffer by putting it in the list of available surfaces if we
// have not reached the maximum amount of cached surfaces.
if (available_surfaces_.size() < kMaxSurfaces) {
available_surfaces_.push_back(std::move(surface));
} else {
TRACE_EVENT_INSTANT0("flutter", "Too many surfaces in pool, dropping");
}
TraceStats();
}
void SoftwareSurfaceProducer::RecyclePendingSurface(uintptr_t surface_key) {
// Before we do anything, we must clear the surface from the collection of
// pending surfaces.
auto found_in_pending = pending_surfaces_.find(surface_key);
if (found_in_pending == pending_surfaces_.end()) {
FML_LOG(ERROR) << "Attempted to recycle a surface that wasn't pending.";
return;
}
// Grab a hold of the surface to recycle and clear the entry in the pending
// surfaces collection.
auto surface_to_recycle = std::move(found_in_pending->second);
pending_surfaces_.erase(found_in_pending);
RecycleSurface(std::move(surface_to_recycle));
}
void SoftwareSurfaceProducer::AgeAndCollectOldBuffers() {
TRACE_EVENT0("flutter", "SoftwareSurfacePool::AgeAndCollectOldBuffers");
// Remove all surfaces that are no longer valid or are too old.
size_t size_before = available_surfaces_.size();
available_surfaces_.erase(
std::remove_if(available_surfaces_.begin(), available_surfaces_.end(),
[&](auto& surface) {
return !surface->IsValid() ||
surface->AdvanceAndGetAge() >= kMaxSurfaceAge;
}),
available_surfaces_.end());
TRACE_EVENT1("flutter", "AgeAndCollect", "aged surfaces",
(size_before - available_surfaces_.size()));
TraceStats();
}
void SoftwareSurfaceProducer::TraceStats() {
// Resources held in cached buffers.
size_t cached_surfaces_bytes = 0;
for (const auto& surface : available_surfaces_) {
cached_surfaces_bytes += surface->GetAllocationSize();
}
TRACE_COUNTER("flutter", "SurfacePoolCounts", 0u, "CachedCount",
available_surfaces_.size(), //
"Created", trace_surfaces_created_, //
"Reused", trace_surfaces_reused_, //
"PendingInCompositor", pending_surfaces_.size(), //
"Retained", 0 //
);
TRACE_COUNTER("flutter", "SurfacePoolBytes", 0u, //
"CachedBytes", cached_surfaces_bytes, //
"RetainedBytes", 0 //
);
// Reset per present/frame stats.
trace_surfaces_created_ = 0;
trace_surfaces_reused_ = 0;
}
} // namespace flutter_runner