DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Add support for trace counters with variable arguments and instrument the raster cache. (#8094)" (#8122)

Browse Source 
This reverts commit 2a0d3542851ae59c2d2f490d1111eeb57b0da388.
This commit is contained in:
Chinmay Garde 2019-03-11 15:09:24 -07:00 committed by GitHub
parent 2a0d354285
commit bc901324fa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 19 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
flow/raster_cache.cc
View File

@ -97,7 +97,6 @@ static RasterCacheResult Rasterize(
bool checkerboard,
const SkRect& logical_rect,
std::function<void(SkCanvas*)> draw_function) {
TRACE_EVENT0("flutter", "RasterCachePopulate");
SkIRect cache_rect = RasterCache::GetDeviceBounds(logical_rect, ctm);
const SkImageInfo image_info = SkImageInfo::MakeN32Premul(
@ -130,6 +129,8 @@ RasterCacheResult RasterizePicture(SkPicture* picture,
const SkMatrix& ctm,
SkColorSpace* dst_color_space,
bool checkerboard) {
TRACE_EVENT0("flutter", "RasterCachePopulate");
return Rasterize(context, ctm, dst_color_space, checkerboard,
picture->cullRect(),
[=](SkCanvas* canvas) { canvas->drawPicture(picture); });
@ -239,7 +240,6 @@ void RasterCache::SweepAfterFrame() {
SweepOneCacheAfterFrame<PictureCache, PictureCache::iterator>(picture_cache_);
SweepOneCacheAfterFrame<LayerCache, LayerCache::iterator>(layer_cache_);
picture_cached_this_frame_ = 0;
TraceStatsToTimeline();
}
void RasterCache::Clear() {
@ -259,35 +259,4 @@ void RasterCache::SetCheckboardCacheImages(bool checkerboard) {
Clear();
}
void RasterCache::TraceStatsToTimeline() const {
#if FLUTTER_RUNTIME_MODE != FLUTTER_RUNTIME_MODE_RELEASE
size_t layer_cache_count = 0;
size_t layer_cache_bytes = 0;
size_t picture_cache_count = 0;
size_t picture_cache_bytes = 0;
for (const auto& item : layer_cache_) {
const auto dimensions = item.second.image.image_dimensions();
layer_cache_count++;
layer_cache_bytes += dimensions.width() * dimensions.height() * 4;
}
for (const auto& item : picture_cache_) {
const auto dimensions = item.second.image.image_dimensions();
picture_cache_count++;
picture_cache_bytes += dimensions.width() * dimensions.height() * 4;
}
FML_TRACE_COUNTER("flutter", "RasterCache",
reinterpret_cast<int64_t>(this), //
"LayerCount", layer_cache_count, //
"LayerMBytes", layer_cache_bytes * 1e-6, //
"PictureCount", picture_cache_count, //
"PictureMBytes", picture_cache_bytes * 1e-6 //
);
#endif // FLUTTER_RUNTIME_MODE != FLUTTER_RUNTIME_MODE_RELEASE
}
} // namespace flow

7
flow/raster_cache.h
View File

@ -33,10 +33,6 @@ class RasterCacheResult {
void draw(SkCanvas& canvas, const SkPaint* paint = nullptr) const;
SkISize image_dimensions() const {
return image_ ? image_->dimensions() : SkISize::Make(0, 0);
};
private:
sk_sp<SkImage> image_;
SkRect logical_rect_;
@ -91,7 +87,6 @@ class RasterCache {
void Prepare(PrerollContext* context, Layer* layer, const SkMatrix& ctm);
RasterCacheResult Get(const SkPicture& picture, const SkMatrix& ctm) const;
RasterCacheResult Get(Layer* layer, const SkMatrix& ctm) const;
void SweepAfterFrame();
@ -132,8 +127,6 @@ class RasterCache {
bool checkerboard_images_;
fml::WeakPtrFactory<RasterCache> weak_factory_;
void TraceStatsToTimeline() const;
FML_DISALLOW_COPY_AND_ASSIGN(RasterCache);
};

36
fml/trace_event.cc
View File

@ -4,34 +4,22 @@
#include "flutter/fml/trace_event.h"
#include "flutter/fml/logging.h"
#include "third_party/dart/runtime/include/dart_tools_api.h"
namespace fml {
namespace tracing {
void TraceTimelineEvent(TraceArg category_group,
TraceArg name,
TraceIDArg identifier,
Dart_Timeline_Event_Type type,
const std::vector<const char*>& names,
const std::vector<std::string>& values) {
const auto argument_count = std::min(names.size(), values.size());
std::vector<const char*> c_values;
c_values.resize(argument_count, nullptr);
for (size_t i = 0; i < argument_count; i++) {
c_values[i] = values[i].c_str();
}
Dart_TimelineEvent(
name, // label
Dart_TimelineGetMicros(), // timestamp0
identifier, // timestamp1_or_async_id
type, // event type
argument_count, // argument_count
const_cast<const char**>(names.data()), // argument_names
const_cast<const char**>(c_values.data()) // argument_values
void TraceCounter(TraceArg category_group, TraceArg name, TraceIDArg count) {
auto count_string = std::to_string(count);
const char* arg_names[] = {name};
const char* arg_values[] = {count_string.c_str()};
Dart_TimelineEvent(name, // label
Dart_TimelineGetMicros(), // timestamp0
0, // timestamp1_or_async_id
Dart_Timeline_Event_Counter, // event type
1, // argument_count
arg_names, // argument_names
arg_values // argument_values
);
}

67
fml/trace_event.h
View File

@ -13,6 +13,8 @@
#include <trace/event.h>
#define FML_TRACE_COUNTER(category_group, name, count) \
TRACE_COUNTER(category_group, name, 0u, name, count)
#define TRACE_EVENT0(a, b) TRACE_DURATION(a, b)
#define TRACE_EVENT1(a, b, c, d) TRACE_DURATION(a, b, c, d)
#define TRACE_EVENT2(a, b, c, d, e, f) TRACE_DURATION(a, b, c, d, e, f)
@ -26,11 +28,8 @@
#include <cstddef>
#include <cstdint>
#include <string>
#include <type_traits>
#include <vector>
#include "flutter/fml/macros.h"
#include "third_party/dart/runtime/include/dart_tools_api.h"
#if !defined(OS_FUCHSIA)
@ -46,8 +45,8 @@
// from trace/event.h on Fuchsia.
//
// TODO(chinmaygarde): All macros here should have the FML prefix.
#define FML_TRACE_COUNTER(category_group, name, counter_id, arg1, args...) \
::fml::tracing::TraceCounter(category_group, name, counter_id, arg1, ##args);
#define FML_TRACE_COUNTER(category_group, name, count) \
::fml::tracing::TraceCounter(category_group, name, count);
#define TRACE_EVENT0(category_group, name) \
::fml::tracing::TraceEvent0(category_group, name); \
@ -100,63 +99,7 @@ namespace tracing {
using TraceArg = const char*;
using TraceIDArg = int64_t;
void TraceTimelineEvent(TraceArg category_group,
TraceArg name,
TraceIDArg id,
Dart_Timeline_Event_Type type,
const std::vector<const char*>& names,
const std::vector<std::string>& values);
inline std::string TraceToString(const char* string) {
return std::string{string};
}
inline std::string TraceToString(std::string string) {
return string;
}
template <typename T, typename = std::enable_if_t<std::is_arithmetic<T>::value>>
std::string TraceToString(T string) {
return std::to_string(string);
}
inline void SplitArgumentsCollect(std::vector<const char*>& keys,
std::vector<std::string>& values) {}
template <typename Key, typename Value, typename... Args>
void SplitArgumentsCollect(std::vector<const char*>& keys,
std::vector<std::string>& values,
Key key,
Value value,
Args... args) {
keys.emplace_back(key);
values.emplace_back(TraceToString(value));
SplitArgumentsCollect(keys, values, args...);
}
inline std::pair<std::vector<const char*>, std::vector<std::string>>
SplitArguments() {
return {};
}
template <typename Key, typename Value, typename... Args>
std::pair<std::vector<const char*>, std::vector<std::string>>
SplitArguments(Key key, Value value, Args... args) {
std::vector<const char*> keys;
std::vector<std::string> values;
SplitArgumentsCollect(keys, values, key, value, args...);
return std::make_pair(std::move(keys), std::move(values));
}
template <typename... Args>
void TraceCounter(TraceArg category,
TraceArg name,
TraceIDArg identifier,
Args... args) {
auto split = SplitArguments(args...);
TraceTimelineEvent(category, name, identifier, Dart_Timeline_Event_Counter,
split.first, split.second);
}
void TraceCounter(TraceArg category_group, TraceArg name, TraceIDArg count);
void TraceEvent0(TraceArg category_group, TraceArg name);