Skip to content
This repository was archived by the owner on Feb 25, 2025. It is now read-only.

Commit 909ea80

Browse files
author
Kaushik Iska
committed
Remove pipeline in favor of layer tree holder
Relanding of a change that was reverted in: #18427
1 parent d13861d commit 909ea80

16 files changed

+226
-498
lines changed

‎ci/licenses_golden/licenses_flutter

+3-3
Original file line numberDiff line numberDiff line change
@@ -584,12 +584,12 @@ FILE: ../../../flutter/shell/common/gl_context_switch_unittests.cc
584584
FILE: ../../../flutter/shell/common/input_events_unittests.cc
585585
FILE: ../../../flutter/shell/common/isolate_configuration.cc
586586
FILE: ../../../flutter/shell/common/isolate_configuration.h
587+
FILE: ../../../flutter/shell/common/layer_tree_holder.cc
588+
FILE: ../../../flutter/shell/common/layer_tree_holder.h
589+
FILE: ../../../flutter/shell/common/layer_tree_holder_unittests.cc
587590
FILE: ../../../flutter/shell/common/persistent_cache.cc
588591
FILE: ../../../flutter/shell/common/persistent_cache.h
589592
FILE: ../../../flutter/shell/common/persistent_cache_unittests.cc
590-
FILE: ../../../flutter/shell/common/pipeline.cc
591-
FILE: ../../../flutter/shell/common/pipeline.h
592-
FILE: ../../../flutter/shell/common/pipeline_unittests.cc
593593
FILE: ../../../flutter/shell/common/platform_view.cc
594594
FILE: ../../../flutter/shell/common/platform_view.h
595595
FILE: ../../../flutter/shell/common/pointer_data_dispatcher.cc

‎shell/common/BUILD.gn

+2-2
Original file line numberDiff line numberDiff line change
@@ -87,10 +87,10 @@ source_set("common") {
8787
"engine.h",
8888
"isolate_configuration.cc",
8989
"isolate_configuration.h",
90+
"layer_tree_holder.cc",
91+
"layer_tree_holder.h",
9092
"persistent_cache.cc",
9193
"persistent_cache.h",
92-
"pipeline.cc",
93-
"pipeline.h",
9494
"platform_view.cc",
9595
"platform_view.h",
9696
"pointer_data_dispatcher.cc",

‎shell/common/animator.cc

+5-40
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
// found in the LICENSE file.
44

55
#include "flutter/shell/common/animator.h"
6+
#include <memory>
67

78
#include "flutter/fml/trace_event.h"
89
#include "third_party/dart/runtime/include/dart_tools_api.h"
@@ -28,27 +29,15 @@ Animator::Animator(Delegate& delegate,
2829
last_frame_begin_time_(),
2930
last_frame_target_time_(),
3031
dart_frame_deadline_(0),
31-
#if FLUTTER_SHELL_ENABLE_METAL
32-
layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(2)),
33-
#else // FLUTTER_SHELL_ENABLE_METAL
34-
// TODO(dnfield): We should remove this logic and set the pipeline depth
35-
// back to 2 in this case. See
36-
// https://github.com/flutter/engine/pull/9132 for discussion.
37-
layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(
38-
task_runners.GetPlatformTaskRunner() ==
39-
task_runners.GetRasterTaskRunner()
40-
? 1
41-
: 2)),
42-
#endif // FLUTTER_SHELL_ENABLE_METAL
32+
layer_tree_holder_(std::make_shared<LayerTreeHolder>()),
4333
pending_frame_semaphore_(1),
4434
frame_number_(1),
4535
paused_(false),
4636
regenerate_layer_tree_(false),
4737
frame_scheduled_(false),
4838
notify_idle_task_id_(0),
4939
dimension_change_pending_(false),
50-
weak_factory_(this) {
51-
}
40+
weak_factory_(this) {}
5241

5342
Animator::~Animator() = default;
5443

@@ -114,25 +103,6 @@ void Animator::BeginFrame(fml::TimePoint frame_start_time,
114103
regenerate_layer_tree_ = false;
115104
pending_frame_semaphore_.Signal();
116105

117-
if (!producer_continuation_) {
118-
// We may already have a valid pipeline continuation in case a previous
119-
// begin frame did not result in an Animation::Render. Simply reuse that
120-
// instead of asking the pipeline for a fresh continuation.
121-
producer_continuation_ = layer_tree_pipeline_->Produce();
122-
123-
if (!producer_continuation_) {
124-
// If we still don't have valid continuation, the pipeline is currently
125-
// full because the consumer is being too slow. Try again at the next
126-
// frame interval.
127-
RequestFrame();
128-
return;
129-
}
130-
}
131-
132-
// We have acquired a valid continuation from the pipeline and are ready
133-
// to service potential frame.
134-
FML_DCHECK(producer_continuation_);
135-
136106
last_frame_begin_time_ = frame_start_time;
137107
last_frame_target_time_ = frame_target_time;
138108
dart_frame_deadline_ = FxlToDartOrEarlier(frame_target_time);
@@ -184,13 +154,8 @@ void Animator::Render(std::unique_ptr<flutter::LayerTree> layer_tree) {
184154
last_frame_target_time_);
185155
}
186156

187-
// Commit the pending continuation.
188-
bool result = producer_continuation_.Complete(std::move(layer_tree));
189-
if (!result) {
190-
FML_DLOG(INFO) << "No pending continuation to commit";
191-
}
192-
193-
delegate_.OnAnimatorDraw(layer_tree_pipeline_, last_frame_target_time_);
157+
layer_tree_holder_->PushIfNewer(std::move(layer_tree));
158+
delegate_.OnAnimatorDraw(layer_tree_holder_, last_frame_target_time_);
194159
}
195160

196161
bool Animator::CanReuseLastLayerTree() {

‎shell/common/animator.h

+4-6
Original file line numberDiff line numberDiff line change
@@ -6,13 +6,14 @@
66
#define FLUTTER_SHELL_COMMON_ANIMATOR_H_
77

88
#include <deque>
9+
#include <memory>
910

1011
#include "flutter/common/task_runners.h"
1112
#include "flutter/fml/memory/ref_ptr.h"
1213
#include "flutter/fml/memory/weak_ptr.h"
1314
#include "flutter/fml/synchronization/semaphore.h"
1415
#include "flutter/fml/time/time_point.h"
15-
#include "flutter/shell/common/pipeline.h"
16+
#include "flutter/shell/common/layer_tree_holder.h"
1617
#include "flutter/shell/common/rasterizer.h"
1718
#include "flutter/shell/common/vsync_waiter.h"
1819

@@ -35,7 +36,7 @@ class Animator final {
3536
virtual void OnAnimatorNotifyIdle(int64_t deadline) = 0;
3637

3738
virtual void OnAnimatorDraw(
38-
fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline,
39+
std::shared_ptr<LayerTreeHolder> layer_tree_holder,
3940
fml::TimePoint frame_target_time) = 0;
4041

4142
virtual void OnAnimatorDrawLastLayerTree() = 0;
@@ -81,8 +82,6 @@ class Animator final {
8182
void EnqueueTraceFlowId(uint64_t trace_flow_id);
8283

8384
private:
84-
using LayerTreePipeline = Pipeline<flutter::LayerTree>;
85-
8685
void BeginFrame(fml::TimePoint frame_start_time,
8786
fml::TimePoint frame_target_time);
8887

@@ -100,9 +99,8 @@ class Animator final {
10099
fml::TimePoint last_frame_begin_time_;
101100
fml::TimePoint last_frame_target_time_;
102101
int64_t dart_frame_deadline_;
103-
fml::RefPtr<LayerTreePipeline> layer_tree_pipeline_;
102+
std::shared_ptr<LayerTreeHolder> layer_tree_holder_;
104103
fml::Semaphore pending_frame_semaphore_;
105-
LayerTreePipeline::ProducerContinuation producer_continuation_;
106104
int64_t frame_number_;
107105
bool paused_;
108106
bool regenerate_layer_tree_;

‎shell/common/engine.h

+7-14
Original file line numberDiff line numberDiff line change
@@ -411,25 +411,18 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
411411
/// will cause the jank in the Flutter application:
412412
/// * The time taken by this method to create a layer-tree exceeds
413413
/// on frame interval (for example, 16.66 ms on a 60Hz display).
414-
/// * The time take by this method to generate a new layer-tree
415-
/// causes the current layer-tree pipeline depth to change. To
416-
/// illustrate this point, note that maximum pipeline depth used
417-
/// by layer tree in the engine is 2. If both the UI and GPU
418-
/// task runner tasks finish within one frame interval, the
419-
/// pipeline depth is one. If the UI thread happens to be
420-
/// working on a frame when the raster thread is still not done
421-
/// with the previous frame, the pipeline depth is 2. When the
422-
/// pipeline depth changes from 1 to 2, animations and UI
423-
/// interactions that cause the generation of the new layer tree
424-
/// appropriate for (frame_time + one frame interval) will
425-
/// actually end up at (frame_time + two frame intervals). This
426-
/// is not what code running on the UI thread expected would
427-
/// happen. This causes perceptible jank.
414+
/// * A new layer-tree produced by this method replaces a stale
415+
/// layer tree in `LayerTreeHolder`. See:
416+
/// `LayerTreeHolder::ReplaceIfNewer`. This could happen if
417+
/// rasterizer takes more than one frame interval to rasterize a
418+
/// layer tree. This would cause some frames to be skipped and
419+
/// could result in perceptible jank.
428420
///
429421
/// @param[in] frame_time The point at which the current frame interval
430422
/// began. May be used by animation interpolators,
431423
/// physics simulations, etc..
432424
///
425+
/// @see `LayerTreeHolder::ReplaceIfNewer`
433426
void BeginFrame(fml::TimePoint frame_time);
434427

435428
//----------------------------------------------------------------------------

‎shell/common/layer_tree_holder.cc

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
// Copyright 2013 The Flutter Authors. All rights reserved.
2+
// Use of this source code is governed by a BSD-style license that can be
3+
// found in the LICENSE file.
4+
5+
#include "flutter/shell/common/layer_tree_holder.h"
6+
7+
namespace flutter {
8+
9+
LayerTreeHolder::LayerTreeHolder() = default;
10+
11+
LayerTreeHolder::~LayerTreeHolder() = default;
12+
13+
std::unique_ptr<LayerTree> LayerTreeHolder::Pop() {
14+
std::scoped_lock lock(layer_tree_mutex);
15+
return std::move(layer_tree_);
16+
}
17+
18+
void LayerTreeHolder::PushIfNewer(
19+
std::unique_ptr<LayerTree> proposed_layer_tree) {
20+
std::scoped_lock lock(layer_tree_mutex);
21+
if (!layer_tree_ ||
22+
layer_tree_->target_time() < proposed_layer_tree->target_time()) {
23+
layer_tree_ = std::move(proposed_layer_tree);
24+
}
25+
}
26+
27+
bool LayerTreeHolder::IsEmpty() const {
28+
std::scoped_lock lock(layer_tree_mutex);
29+
return !layer_tree_;
30+
}
31+
32+
}; // namespace flutter

‎shell/common/layer_tree_holder.h

+55
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
// Copyright 2013 The Flutter Authors. All rights reserved.
2+
// Use of this source code is governed by a BSD-style license that can be
3+
// found in the LICENSE file.
4+
5+
#ifndef FLUTTER_SHELL_COMMON_LAYER_TREE_HOLDER_H_
6+
#define FLUTTER_SHELL_COMMON_LAYER_TREE_HOLDER_H_
7+
8+
#include <memory>
9+
10+
#include "flow/layers/layer_tree.h"
11+
12+
namespace flutter {
13+
14+
/**
15+
* @brief Holds the next `flutter::LayerTree` that needs to be rasterized. The
16+
* accesses to `LayerTreeHolder` are thread safe. This is important as this
17+
* component is accessed from both the UI and the Raster threads.
18+
*
19+
* A typical flow of events through this component would be:
20+
* 1. `flutter::Animator` pushed a layer tree to be rendered during each
21+
* `Animator::Render` call.
22+
* 2. `flutter::Rasterizer::Draw` consumes the pushed layer tree via `Pop`.
23+
*
24+
* It is important to note that if a layer tree held by this class is yet to be
25+
* consumed, it can be overriden by a newer layer tree produced by the
26+
* `Animator`. The newness of the layer tree is determined by the target time.
27+
*/
28+
class LayerTreeHolder {
29+
public:
30+
LayerTreeHolder();
31+
32+
~LayerTreeHolder();
33+
34+
/**
35+
* @brief Checks if a layer tree is currently held.
36+
*
37+
* @return true is no layer tree is held.
38+
* @return false if there is a layer tree waiting to be consumed.
39+
*/
40+
bool IsEmpty() const;
41+
42+
[[nodiscard]] std::unique_ptr<LayerTree> Pop();
43+
44+
void PushIfNewer(std::unique_ptr<LayerTree> proposed_layer_tree);
45+
46+
private:
47+
mutable std::mutex layer_tree_mutex;
48+
std::unique_ptr<LayerTree> layer_tree_;
49+
50+
FML_DISALLOW_COPY_AND_ASSIGN(LayerTreeHolder);
51+
};
52+
53+
}; // namespace flutter
54+
55+
#endif // FLUTTER_SHELL_COMMON_LAYER_TREE_HOLDER_H_

‎shell/common/layer_tree_holder_unittests.cc

+76
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
// Copyright 2013 The Flutter Authors. All rights reserved.
2+
// Use of this source code is governed by a BSD-style license that can be
3+
// found in the LICENSE file.
4+
5+
#define FML_USED_ON_EMBEDDER
6+
7+
#include <functional>
8+
#include <future>
9+
#include <memory>
10+
11+
#include "flutter/shell/common/layer_tree_holder.h"
12+
#include "gtest/gtest.h"
13+
14+
namespace flutter {
15+
namespace testing {
16+
17+
TEST(LayerTreeHolder, EmptyOnInit) {
18+
const LayerTreeHolder layer_tree_holder;
19+
ASSERT_TRUE(layer_tree_holder.IsEmpty());
20+
}
21+
22+
TEST(LayerTreeHolder, PutOneAndGet) {
23+
LayerTreeHolder layer_tree_holder;
24+
const auto frame_size = SkISize::Make(64, 64);
25+
auto layer_tree = std::make_unique<LayerTree>(frame_size, 100.0f, 1.0f);
26+
layer_tree_holder.PushIfNewer(std::move(layer_tree));
27+
ASSERT_FALSE(layer_tree_holder.IsEmpty());
28+
const auto stored = layer_tree_holder.Pop();
29+
ASSERT_EQ(stored->frame_size(), frame_size);
30+
ASSERT_TRUE(layer_tree_holder.IsEmpty());
31+
}
32+
33+
TEST(LayerTreeHolder, PutMultiGetsLatest) {
34+
const auto build_begin = fml::TimePoint::Now();
35+
const auto target_time_1 = build_begin + fml::TimeDelta::FromSeconds(2);
36+
const auto target_time_2 = build_begin + fml::TimeDelta::FromSeconds(5);
37+
38+
LayerTreeHolder layer_tree_holder;
39+
const auto frame_size_1 = SkISize::Make(64, 64);
40+
auto layer_tree_1 = std::make_unique<LayerTree>(frame_size_1, 100.0f, 1.0f);
41+
layer_tree_1->RecordBuildTime(build_begin, target_time_1);
42+
layer_tree_holder.PushIfNewer(std::move(layer_tree_1));
43+
44+
const auto frame_size_2 = SkISize::Make(128, 128);
45+
auto layer_tree_2 = std::make_unique<LayerTree>(frame_size_2, 100.0f, 1.0f);
46+
layer_tree_2->RecordBuildTime(build_begin, target_time_2);
47+
layer_tree_holder.PushIfNewer(std::move(layer_tree_2));
48+
49+
const auto stored = layer_tree_holder.Pop();
50+
ASSERT_EQ(stored->frame_size(), frame_size_2);
51+
ASSERT_TRUE(layer_tree_holder.IsEmpty());
52+
}
53+
54+
TEST(LayerTreeHolder, RetainsOlderIfNewerFrameHasEarlierTargetTime) {
55+
const auto build_begin = fml::TimePoint::Now();
56+
const auto target_time_1 = build_begin + fml::TimeDelta::FromSeconds(5);
57+
const auto target_time_2 = build_begin + fml::TimeDelta::FromSeconds(2);
58+
59+
LayerTreeHolder layer_tree_holder;
60+
const auto frame_size_1 = SkISize::Make(64, 64);
61+
auto layer_tree_1 = std::make_unique<LayerTree>(frame_size_1, 100.0f, 1.0f);
62+
layer_tree_1->RecordBuildTime(build_begin, target_time_1);
63+
layer_tree_holder.PushIfNewer(std::move(layer_tree_1));
64+
65+
const auto frame_size_2 = SkISize::Make(128, 128);
66+
auto layer_tree_2 = std::make_unique<LayerTree>(frame_size_2, 100.0f, 1.0f);
67+
layer_tree_2->RecordBuildTime(build_begin, target_time_2);
68+
layer_tree_holder.PushIfNewer(std::move(layer_tree_2));
69+
70+
const auto stored = layer_tree_holder.Pop();
71+
ASSERT_EQ(stored->frame_size(), frame_size_1);
72+
ASSERT_TRUE(layer_tree_holder.IsEmpty());
73+
}
74+
75+
} // namespace testing
76+
} // namespace flutter

‎shell/common/pipeline.cc

-14
This file was deleted.

0 commit comments

Comments
 (0)