summaryrefslogtreecommitdiffstats
path: root/cc/debug
diff options
context:
space:
mode:
Diffstat (limited to 'cc/debug')
-rw-r--r--cc/debug/rendering_stats.cc217
-rw-r--r--cc/debug/rendering_stats.h104
-rw-r--r--cc/debug/rendering_stats_instrumentation.cc71
-rw-r--r--cc/debug/rendering_stats_instrumentation.h26
4 files changed, 278 insertions, 140 deletions
diff --git a/cc/debug/rendering_stats.cc b/cc/debug/rendering_stats.cc
index 12c5453..e6875ce 100644
--- a/cc/debug/rendering_stats.cc
+++ b/cc/debug/rendering_stats.cc
@@ -2,98 +2,179 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "base/values.h"
#include "cc/debug/rendering_stats.h"
namespace cc {
-RenderingStats::RenderingStats()
- : animation_frame_count(0),
- screen_frame_count(0),
+MainThreadRenderingStats::MainThreadRenderingStats()
+ : animation_frame_count(0),
+ screen_frame_count(0),
+ commit_count(0),
+ painted_pixel_count(0),
+ recorded_pixel_count(0),
+ image_gathering_count(0) {}
+
+ImplThreadRenderingStats::ImplThreadRenderingStats()
+ : screen_frame_count(0),
dropped_frame_count(0),
- total_commit_count(0),
- total_pixels_painted(0),
- total_pixels_recorded(0),
- total_pixels_rasterized(0),
- num_impl_thread_scrolls(0),
- num_main_thread_scrolls(0),
- num_layers_drawn(0),
- num_missing_tiles(0),
- total_deferred_image_decode_count(0),
- total_deferred_image_cache_hit_count(0),
- total_image_gathering_count(0),
- total_tiles_analyzed(0),
- solid_color_tiles_analyzed(0) {}
+ rasterized_pixel_count(0),
+ impl_thread_scroll_count(0),
+ main_thread_scroll_count(0),
+ drawn_layer_count(0),
+ missing_tile_count(0),
+ deferred_image_decode_count(0),
+ deferred_image_cache_hit_count(0),
+ tile_analysis_count(0),
+ solid_color_tile_analysis_count(0) {}
void RenderingStats::EnumerateFields(Enumerator* enumerator) const {
- enumerator->AddInt64("numAnimationFrames", animation_frame_count);
- enumerator->AddInt64("numFramesSentToScreen", screen_frame_count);
- enumerator->AddInt64("droppedFrameCount", dropped_frame_count);
+ enumerator->AddInt64("numAnimationFrames",
+ main_stats.animation_frame_count);
+ enumerator->AddInt64("numFramesSentToScreen", main_stats.screen_frame_count +
+ impl_stats.screen_frame_count);
enumerator->AddDouble("totalPaintTimeInSeconds",
- total_paint_time.InSecondsF());
+ main_stats.paint_time.InSecondsF());
enumerator->AddDouble("totalRecordTimeInSeconds",
- total_record_time.InSecondsF());
+ main_stats.record_time.InSecondsF());
+ enumerator->AddDouble("totalCommitTimeInSeconds",
+ main_stats.commit_time.InSecondsF());
+ enumerator->AddInt64("totalCommitCount", main_stats.commit_count);
+ enumerator->AddInt64("totalPixelsPainted", main_stats.painted_pixel_count);
+ enumerator->AddInt64("totalPixelsRecorded", main_stats.recorded_pixel_count);
+ enumerator->AddInt64("totalImageGatheringCount",
+ main_stats.image_gathering_count);
+ enumerator->AddDouble("totalImageGatheringTimeInSeconds",
+ main_stats.image_gathering_time.InSecondsF());
+ enumerator->AddInt64("droppedFrameCount", impl_stats.dropped_frame_count);
enumerator->AddDouble("totalRasterizeTimeInSeconds",
- total_rasterize_time.InSecondsF());
+ impl_stats.rasterize_time.InSecondsF());
enumerator->AddDouble(
"totalRasterizeTimeForNowBinsOnPendingTree",
- total_rasterize_time_for_now_bins_on_pending_tree.InSecondsF());
- enumerator->AddDouble("totalCommitTimeInSeconds",
- total_commit_time.InSecondsF());
+ impl_stats.rasterize_time_for_now_bins_on_pending_tree.InSecondsF());
enumerator->AddDouble("bestRasterizeTimeInSeconds",
- best_rasterize_time.InSecondsF());
- enumerator->AddInt64("totalCommitCount", total_commit_count);
- enumerator->AddInt64("totalPixelsPainted", total_pixels_painted);
- enumerator->AddInt64("totalPixelsRecorded", total_pixels_recorded);
- enumerator->AddInt64("totalPixelsRasterized", total_pixels_rasterized);
- enumerator->AddInt64("numImplThreadScrolls", num_impl_thread_scrolls);
- enumerator->AddInt64("numMainThreadScrolls", num_main_thread_scrolls);
- enumerator->AddInt64("numLayersDrawn", num_layers_drawn);
- enumerator->AddInt64("numMissingTiles", num_missing_tiles);
+ impl_stats.best_rasterize_time.InSecondsF());
+ enumerator->AddInt64("totalPixelsRasterized",
+ impl_stats.rasterized_pixel_count);
+ enumerator->AddInt64("numImplThreadScrolls",
+ impl_stats.impl_thread_scroll_count);
+ enumerator->AddInt64("numMainThreadScrolls",
+ impl_stats.main_thread_scroll_count);
+ enumerator->AddInt64("numLayersDrawn", impl_stats.drawn_layer_count);
+ enumerator->AddInt64("numMissingTiles", impl_stats.missing_tile_count);
enumerator->AddInt64("totalDeferredImageDecodeCount",
- total_deferred_image_decode_count);
- enumerator->AddInt64("totalTilesAnalyzed", total_tiles_analyzed);
+ impl_stats.deferred_image_decode_count);
+ enumerator->AddInt64("totalTilesAnalyzed", impl_stats.tile_analysis_count);
enumerator->AddInt64("solidColorTilesAnalyzed",
- solid_color_tiles_analyzed);
+ impl_stats.solid_color_tile_analysis_count);
enumerator->AddInt64("totalDeferredImageCacheHitCount",
- total_deferred_image_cache_hit_count);
- enumerator->AddInt64("totalImageGatheringCount",
- total_image_gathering_count);
+ impl_stats.deferred_image_cache_hit_count);
enumerator->AddDouble("totalDeferredImageDecodeTimeInSeconds",
- total_deferred_image_decode_time.InSecondsF());
- enumerator->AddDouble("totalImageGatheringTimeInSeconds",
- total_image_gathering_time.InSecondsF());
+ impl_stats.deferred_image_decode_time.InSecondsF());
enumerator->AddDouble("totalTileAnalysisTimeInSeconds",
- total_tile_analysis_time.InSecondsF());
+ impl_stats.tile_analysis_time.InSecondsF());
}
-void RenderingStats::Add(const RenderingStats& other) {
+scoped_ptr<base::debug::ConvertableToTraceFormat>
+MainThreadRenderingStats::AsTraceableData() const {
+ scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
+ record_data->SetInteger("animation_frame_count",
+ animation_frame_count);
+ record_data->SetInteger("screen_frame_count",
+ screen_frame_count);
+ record_data->SetDouble("paint_time",
+ paint_time.InSecondsF());
+ record_data->SetDouble("record_time",
+ record_time.InSecondsF());
+ record_data->SetDouble("commit_time",
+ commit_time.InSecondsF());
+ record_data->SetInteger("commit_count",
+ commit_count);
+ record_data->SetInteger("painted_pixel_count",
+ painted_pixel_count);
+ record_data->SetInteger("recorded_pixel_count",
+ recorded_pixel_count);
+ record_data->SetInteger("image_gathering_count",
+ image_gathering_count);
+ return TracedValue::FromValue(record_data.release());
+}
+
+scoped_ptr<base::debug::ConvertableToTraceFormat>
+ImplThreadRenderingStats::AsTraceableData() const {
+ scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
+ record_data->SetInteger("screen_frame_count",
+ screen_frame_count);
+ record_data->SetInteger("dropped_frame_count",
+ dropped_frame_count);
+ record_data->SetDouble("rasterize_time",
+ rasterize_time.InSecondsF());
+ record_data->SetDouble(
+ "rasterize_time_for_now_bins_on_pending_tree",
+ rasterize_time_for_now_bins_on_pending_tree.InSecondsF());
+ record_data->SetDouble("best_rasterize_time",
+ best_rasterize_time.InSecondsF());
+ record_data->SetInteger("rasterized_pixel_count",
+ rasterized_pixel_count);
+ record_data->SetInteger("impl_thread_scroll_count",
+ impl_thread_scroll_count);
+ record_data->SetInteger("main_thread_scroll_count",
+ main_thread_scroll_count);
+ record_data->SetInteger("drawn_layer_count",
+ drawn_layer_count);
+ record_data->SetInteger("missing_tile_count",
+ missing_tile_count);
+ record_data->SetInteger("deferred_image_decode_count",
+ deferred_image_decode_count);
+ record_data->SetInteger("deferred_image_cache_hit_count",
+ deferred_image_cache_hit_count);
+ record_data->SetInteger("tile_analysis_count",
+ tile_analysis_count);
+ record_data->SetInteger("solid_color_tile_analysis_count",
+ solid_color_tile_analysis_count);
+ record_data->SetDouble("deferred_image_decode_time",
+ deferred_image_decode_time.InSecondsF());
+ record_data->SetDouble("tile_analysis_time",
+ tile_analysis_time.InSecondsF());
+ return TracedValue::FromValue(record_data.release());
+}
+
+
+void MainThreadRenderingStats::Add(const MainThreadRenderingStats& other) {
animation_frame_count += other.animation_frame_count;
screen_frame_count += other.screen_frame_count;
+ paint_time += other.paint_time;
+ record_time += other.record_time;
+ commit_time += other.commit_time;
+ commit_count += other.commit_count;
+ painted_pixel_count += other.painted_pixel_count;
+ recorded_pixel_count += other.recorded_pixel_count;
+ image_gathering_count += other.image_gathering_count;
+ image_gathering_time += other.image_gathering_time;
+}
+
+void ImplThreadRenderingStats::Add(const ImplThreadRenderingStats& other) {
+ screen_frame_count += other.screen_frame_count;
dropped_frame_count += other.dropped_frame_count;
- total_paint_time += other.total_paint_time;
- total_record_time += other.total_record_time;
- total_rasterize_time += other.total_rasterize_time;
- total_rasterize_time_for_now_bins_on_pending_tree +=
- other.total_rasterize_time_for_now_bins_on_pending_tree;
- total_commit_time += other.total_commit_time;
+ rasterize_time += other.rasterize_time;
+ rasterize_time_for_now_bins_on_pending_tree +=
+ other.rasterize_time_for_now_bins_on_pending_tree;
best_rasterize_time += other.best_rasterize_time;
- total_commit_count += other.total_commit_count;
- total_pixels_painted += other.total_pixels_painted;
- total_pixels_recorded += other.total_pixels_recorded;
- total_pixels_rasterized += other.total_pixels_rasterized;
- num_impl_thread_scrolls += other.num_impl_thread_scrolls;
- num_main_thread_scrolls += other.num_main_thread_scrolls;
- num_layers_drawn += other.num_layers_drawn;
- num_missing_tiles += other.num_missing_tiles;
- total_deferred_image_decode_count += other.total_deferred_image_decode_count;
- total_deferred_image_cache_hit_count +=
- other.total_deferred_image_cache_hit_count;
- total_image_gathering_count += other.total_image_gathering_count;
- total_deferred_image_decode_time += other.total_deferred_image_decode_time;
- total_image_gathering_time += other.total_image_gathering_time;
- total_tiles_analyzed += other.total_tiles_analyzed;
- solid_color_tiles_analyzed += other.solid_color_tiles_analyzed;
- total_tile_analysis_time += other.total_tile_analysis_time;
+ rasterized_pixel_count += other.rasterized_pixel_count;
+ impl_thread_scroll_count += other.impl_thread_scroll_count;
+ main_thread_scroll_count += other.main_thread_scroll_count;
+ drawn_layer_count += other.drawn_layer_count;
+ missing_tile_count += other.missing_tile_count;
+ deferred_image_decode_count += other.deferred_image_decode_count;
+ deferred_image_cache_hit_count += other.deferred_image_cache_hit_count;
+ deferred_image_decode_time += other.deferred_image_decode_time;
+ tile_analysis_count += other.tile_analysis_count;
+ solid_color_tile_analysis_count += other.solid_color_tile_analysis_count;
+ tile_analysis_time += other.tile_analysis_time;
+}
+
+void RenderingStats::Add(const RenderingStats& other) {
+ main_stats.Add(other.main_stats);
+ impl_stats.Add(other.impl_stats);
}
} // namespace cc
diff --git a/cc/debug/rendering_stats.h b/cc/debug/rendering_stats.h
index eb01a57..c3647d5 100644
--- a/cc/debug/rendering_stats.h
+++ b/cc/debug/rendering_stats.h
@@ -8,55 +8,77 @@
#include "base/basictypes.h"
#include "base/time/time.h"
#include "cc/base/cc_export.h"
+#include "cc/debug/traced_value.h"
namespace cc {
-struct CC_EXPORT RenderingStats {
+// In conjunction with EnumerateFields, this allows the embedder to
+// enumerate the values in this structure without
+// having to embed references to its specific member variables. This
+// simplifies the addition of new fields to this type.
+class RenderingStatsEnumerator {
+ public:
+ virtual void AddInt64(const char* name, int64 value) = 0;
+ virtual void AddDouble(const char* name, double value) = 0;
+ virtual void AddInt(const char* name, int value) = 0;
+ virtual void AddTimeDeltaInSecondsF(const char* name,
+ const base::TimeDelta& value) = 0;
+
+ protected:
+ virtual ~RenderingStatsEnumerator() {}
+};
+
+struct CC_EXPORT MainThreadRenderingStats {
+ // Note: when adding new members, please remember to update EnumerateFields
+ // and Add in rendering_stats.cc.
+
int64 animation_frame_count;
int64 screen_frame_count;
- int64 dropped_frame_count;
- base::TimeDelta total_paint_time;
- base::TimeDelta total_record_time;
- base::TimeDelta total_rasterize_time;
- base::TimeDelta total_rasterize_time_for_now_bins_on_pending_tree;
- base::TimeDelta total_commit_time;
- base::TimeDelta best_rasterize_time;
- int64 total_commit_count;
- int64 total_pixels_painted;
- int64 total_pixels_recorded;
- int64 total_pixels_rasterized;
- int64 num_impl_thread_scrolls;
- int64 num_main_thread_scrolls;
- int64 num_layers_drawn;
- int64 num_missing_tiles;
- int64 total_deferred_image_decode_count;
- int64 total_deferred_image_cache_hit_count;
- int64 total_image_gathering_count;
- int64 total_tiles_analyzed;
- int64 solid_color_tiles_analyzed;
- base::TimeDelta total_deferred_image_decode_time;
- base::TimeDelta total_image_gathering_time;
- base::TimeDelta total_tile_analysis_time;
+ base::TimeDelta paint_time;
+ base::TimeDelta record_time;
+ base::TimeDelta commit_time;
+ int64 commit_count;
+ int64 painted_pixel_count;
+ int64 recorded_pixel_count;
+ int64 image_gathering_count;
+ base::TimeDelta image_gathering_time;
+
+ MainThreadRenderingStats();
+ scoped_ptr<base::debug::ConvertableToTraceFormat> AsTraceableData() const;
+ void Add(const MainThreadRenderingStats& other);
+};
+
+struct CC_EXPORT ImplThreadRenderingStats {
// Note: when adding new members, please remember to update EnumerateFields
// and Add in rendering_stats.cc.
- RenderingStats();
-
- // In conjunction with EnumerateFields, this allows the embedder to
- // enumerate the values in this structure without
- // having to embed references to its specific member variables. This
- // simplifies the addition of new fields to this type.
- class Enumerator {
- public:
- virtual void AddInt64(const char* name, int64 value) = 0;
- virtual void AddDouble(const char* name, double value) = 0;
- virtual void AddInt(const char* name, int value) = 0;
- virtual void AddTimeDeltaInSecondsF(const char* name,
- const base::TimeDelta& value) = 0;
-
- protected:
- virtual ~Enumerator() {}
- };
+ int64 screen_frame_count;
+ int64 dropped_frame_count;
+ base::TimeDelta rasterize_time;
+ base::TimeDelta rasterize_time_for_now_bins_on_pending_tree;
+ base::TimeDelta best_rasterize_time;
+ int64 rasterized_pixel_count;
+ int64 impl_thread_scroll_count;
+ int64 main_thread_scroll_count;
+ int64 drawn_layer_count;
+ int64 missing_tile_count;
+ int64 deferred_image_decode_count;
+ int64 deferred_image_cache_hit_count;
+ int64 tile_analysis_count;
+ int64 solid_color_tile_analysis_count;
+ base::TimeDelta deferred_image_decode_time;
+ base::TimeDelta tile_analysis_time;
+
+ ImplThreadRenderingStats();
+ scoped_ptr<base::debug::ConvertableToTraceFormat> AsTraceableData() const;
+ void Add(const ImplThreadRenderingStats& other);
+};
+
+struct CC_EXPORT RenderingStats {
+ typedef RenderingStatsEnumerator Enumerator;
+
+ MainThreadRenderingStats main_stats;
+ ImplThreadRenderingStats impl_stats;
// Outputs the fields in this structure to the provided enumerator.
void EnumerateFields(Enumerator* enumerator) const;
diff --git a/cc/debug/rendering_stats_instrumentation.cc b/cc/debug/rendering_stats_instrumentation.cc
index b3886af..3c164f9 100644
--- a/cc/debug/rendering_stats_instrumentation.cc
+++ b/cc/debug/rendering_stats_instrumentation.cc
@@ -20,7 +20,22 @@ RenderingStatsInstrumentation::~RenderingStatsInstrumentation() {}
RenderingStats RenderingStatsInstrumentation::GetRenderingStats() {
base::AutoLock scoped_lock(lock_);
- return rendering_stats_;
+ RenderingStats rendering_stats;
+ rendering_stats.main_stats = main_stats_accu_;
+ rendering_stats.main_stats.Add(main_stats_);
+ rendering_stats.impl_stats = impl_stats_accu_;
+ rendering_stats.impl_stats.Add(impl_stats_);
+ return rendering_stats;
+}
+
+void RenderingStatsInstrumentation::AccumulateAndClearMainThreadStats() {
+ main_stats_accu_.Add(main_stats_);
+ main_stats_ = MainThreadRenderingStats();
+}
+
+void RenderingStatsInstrumentation::AccumulateAndClearImplThreadStats() {
+ impl_stats_accu_.Add(impl_stats_);
+ impl_stats_ = ImplThreadRenderingStats();
}
base::TimeTicks RenderingStatsInstrumentation::StartRecording() const {
@@ -41,23 +56,23 @@ void RenderingStatsInstrumentation::IncrementAnimationFrameCount() {
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.animation_frame_count++;
+ main_stats_.animation_frame_count++;
}
-void RenderingStatsInstrumentation::SetScreenFrameCount(int64 count) {
+void RenderingStatsInstrumentation::IncrementScreenFrameCount(int64 count) {
if (!record_rendering_stats_)
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.screen_frame_count = count;
+ impl_stats_.screen_frame_count += count;
}
-void RenderingStatsInstrumentation::SetDroppedFrameCount(int64 count) {
+void RenderingStatsInstrumentation::IncrementDroppedFrameCount(int64 count) {
if (!record_rendering_stats_)
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.dropped_frame_count = count;
+ impl_stats_.dropped_frame_count += count;
}
void RenderingStatsInstrumentation::AddCommit(base::TimeDelta duration) {
@@ -65,8 +80,8 @@ void RenderingStatsInstrumentation::AddCommit(base::TimeDelta duration) {
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_commit_time += duration;
- rendering_stats_.total_commit_count++;
+ main_stats_.commit_time += duration;
+ main_stats_.commit_count++;
}
void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
@@ -75,8 +90,8 @@ void RenderingStatsInstrumentation::AddPaint(base::TimeDelta duration,
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_paint_time += duration;
- rendering_stats_.total_pixels_painted += pixels;
+ main_stats_.paint_time += duration;
+ main_stats_.painted_pixel_count += pixels;
}
void RenderingStatsInstrumentation::AddRecord(base::TimeDelta duration,
@@ -85,8 +100,8 @@ void RenderingStatsInstrumentation::AddRecord(base::TimeDelta duration,
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_record_time += duration;
- rendering_stats_.total_pixels_recorded += pixels;
+ main_stats_.record_time += duration;
+ main_stats_.recorded_pixel_count += pixels;
}
void RenderingStatsInstrumentation::AddRaster(base::TimeDelta total_duration,
@@ -97,12 +112,12 @@ void RenderingStatsInstrumentation::AddRaster(base::TimeDelta total_duration,
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_rasterize_time += total_duration;
- rendering_stats_.best_rasterize_time += best_duration;
- rendering_stats_.total_pixels_rasterized += pixels;
+ impl_stats_.rasterize_time += total_duration;
+ impl_stats_.best_rasterize_time += best_duration;
+ impl_stats_.rasterized_pixel_count += pixels;
if (is_in_pending_tree_now_bin) {
- rendering_stats_.total_rasterize_time_for_now_bins_on_pending_tree +=
+ impl_stats_.rasterize_time_for_now_bins_on_pending_tree +=
total_duration;
}
}
@@ -112,7 +127,7 @@ void RenderingStatsInstrumentation::IncrementImplThreadScrolls() {
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.num_impl_thread_scrolls++;
+ impl_stats_.impl_thread_scroll_count++;
}
void RenderingStatsInstrumentation::IncrementMainThreadScrolls() {
@@ -120,7 +135,7 @@ void RenderingStatsInstrumentation::IncrementMainThreadScrolls() {
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.num_main_thread_scrolls++;
+ impl_stats_.main_thread_scroll_count++;
}
void RenderingStatsInstrumentation::AddLayersDrawn(int64 amount) {
@@ -128,7 +143,7 @@ void RenderingStatsInstrumentation::AddLayersDrawn(int64 amount) {
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.num_layers_drawn += amount;
+ impl_stats_.drawn_layer_count += amount;
}
void RenderingStatsInstrumentation::AddMissingTiles(int64 amount) {
@@ -136,7 +151,7 @@ void RenderingStatsInstrumentation::AddMissingTiles(int64 amount) {
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.num_missing_tiles += amount;
+ impl_stats_.missing_tile_count += amount;
}
void RenderingStatsInstrumentation::AddDeferredImageDecode(
@@ -145,8 +160,8 @@ void RenderingStatsInstrumentation::AddDeferredImageDecode(
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_deferred_image_decode_time += duration;
- rendering_stats_.total_deferred_image_decode_count++;
+ impl_stats_.deferred_image_decode_time += duration;
+ impl_stats_.deferred_image_decode_count++;
}
void RenderingStatsInstrumentation::AddImageGathering(
@@ -155,8 +170,8 @@ void RenderingStatsInstrumentation::AddImageGathering(
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_image_gathering_time += duration;
- rendering_stats_.total_image_gathering_count++;
+ main_stats_.image_gathering_time += duration;
+ main_stats_.image_gathering_count++;
}
void RenderingStatsInstrumentation::IncrementDeferredImageCacheHitCount() {
@@ -164,7 +179,7 @@ void RenderingStatsInstrumentation::IncrementDeferredImageCacheHitCount() {
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_deferred_image_cache_hit_count++;
+ impl_stats_.deferred_image_cache_hit_count++;
}
void RenderingStatsInstrumentation::AddAnalysisResult(
@@ -174,10 +189,10 @@ void RenderingStatsInstrumentation::AddAnalysisResult(
return;
base::AutoLock scoped_lock(lock_);
- rendering_stats_.total_tiles_analyzed++;
- rendering_stats_.total_tile_analysis_time += duration;
+ impl_stats_.tile_analysis_count++;
+ impl_stats_.tile_analysis_time += duration;
if (is_solid_color)
- rendering_stats_.solid_color_tiles_analyzed++;
+ impl_stats_.solid_color_tile_analysis_count++;
}
} // namespace cc
diff --git a/cc/debug/rendering_stats_instrumentation.h b/cc/debug/rendering_stats_instrumentation.h
index 6f7515a..a7f9b308 100644
--- a/cc/debug/rendering_stats_instrumentation.h
+++ b/cc/debug/rendering_stats_instrumentation.h
@@ -18,8 +18,24 @@ class CC_EXPORT RenderingStatsInstrumentation {
static scoped_ptr<RenderingStatsInstrumentation> Create();
virtual ~RenderingStatsInstrumentation();
+ // Return current main thread rendering stats.
+ MainThreadRenderingStats GetMainThreadRenderingStats() {
+ return main_stats_;
+ }
+ // Return current impl thread rendering stats.
+ ImplThreadRenderingStats GetImplThreadRenderingStats() {
+ return impl_stats_;
+ }
+ // Return the accumulated, combined rendering stats.
RenderingStats GetRenderingStats();
+ // Add current main thread rendering stats to accumulator and
+ // clear current stats
+ void AccumulateAndClearMainThreadStats();
+ // Add current impl thread rendering stats to accumulator and
+ // clear current stats
+ void AccumulateAndClearImplThreadStats();
+
// Read and write access to the record_rendering_stats_ flag is not locked to
// improve performance. The flag is commonly turned off and hardly changes
// it's value during runtime.
@@ -33,8 +49,8 @@ class CC_EXPORT RenderingStatsInstrumentation {
base::TimeDelta EndRecording(base::TimeTicks start_time) const;
void IncrementAnimationFrameCount();
- void SetScreenFrameCount(int64 count);
- void SetDroppedFrameCount(int64 count);
+ void IncrementScreenFrameCount(int64 count);
+ void IncrementDroppedFrameCount(int64 count);
void AddCommit(base::TimeDelta duration);
void AddPaint(base::TimeDelta duration, int64 pixels);
@@ -61,7 +77,11 @@ class CC_EXPORT RenderingStatsInstrumentation {
RenderingStatsInstrumentation();
private:
- RenderingStats rendering_stats_;
+ MainThreadRenderingStats main_stats_;
+ MainThreadRenderingStats main_stats_accu_;
+ ImplThreadRenderingStats impl_stats_;
+ ImplThreadRenderingStats impl_stats_accu_;
+
bool record_rendering_stats_;
base::Lock lock_;
generated by cgit v1.1 at 2025-02-14 19:39:42 +0000