flutter::Pipeline< R > Class Template Reference

#include <pipeline.h>

Classes
class	ProducerContinuation

Public Types
using	Resource = R
using	ResourcePtr = std::unique_ptr< Resource >
using	Consumer = std::function< void(ResourcePtr)>

Public Member Functions
	Pipeline (uint32_t depth)
	~Pipeline ()=default
bool	IsValid () const
ProducerContinuation	Produce ()
ProducerContinuation	ProduceIfEmpty ()
PipelineConsumeResult	Consume (const Consumer &consumer)

Detailed Description

template<class R>
class flutter::Pipeline< R >

A thread-safe queue of resources for a single consumer and a single producer, with a maximum queue depth.

Pipelines support two key operations: produce and consume.

The consumer calls |Consume| to wait for a resource to be produced and consume it when ready.

The producer calls |Produce| to generate a ProducerContinuation which provides a means to enqueue a resource in the pipeline, if the pipeline is below its maximum depth. When the resource has been prepared, the producer calls Complete on the continuation, which enqueues the resource and signals the waiting consumer.

Pipelines generate the following tracing information:

• PipelineItem: async flow tracking time taken from the time a producer calls |Produce| to the time a consumer consumes calls |Consume|.
• PipelineProduce: async flow tracking time taken from the time a producer calls |Produce| to the time they complete the ProducerContinuation with a resource.
• Pipeline Depth: counter of inflight resource producers.

The primary use of this class is as the frame pipeline used in Flutter's animator/rasterizer.

Definition at line 64 of file pipeline.h.

Member Typedef Documentation

Consumer

template<class R >

using flutter::Pipeline< R >::Consumer = std::function<void(ResourcePtr)>

Definition at line 180 of file pipeline.h.

Resource

template<class R >

using flutter::Pipeline< R >::Resource = R

Definition at line 66 of file pipeline.h.

ResourcePtr

template<class R >

using flutter::Pipeline< R >::ResourcePtr = std::unique_ptr<Resource>

Definition at line 67 of file pipeline.h.

Constructor & Destructor Documentation

Pipeline()

template<class R >

flutter::Pipeline< R >::Pipeline ( uint32_t  depth )

inlineexplicit

Definition at line 131 of file pipeline.h.

      : empty_(depth), available_(0), inflight_(0) {}

~Pipeline()

template<class R >

flutter::Pipeline< R >::~Pipeline ( )

default

Member Function Documentation

Consume()

template<class R >

PipelineConsumeResult flutter::Pipeline< R >::Consume ( const Consumer &  consumer )

inline

Note

Procedure doesn't copy all closures.

Definition at line 183 of file pipeline.h.

                                                                        {
    if (consumer == nullptr) {
      return PipelineConsumeResult::NoneAvailable;
    }
 
    if (!available_.TryWait()) {
      return PipelineConsumeResult::NoneAvailable;
    }
 
    ResourcePtr resource;
    size_t trace_id = 0;
    size_t items_count = 0;
 
    {
      std::scoped_lock lock(queue_mutex_);
      std::tie(resource, trace_id) = std::move(queue_.front());
      queue_.pop_front();
      items_count = queue_.size();
    }
 
    consumer(std::move(resource));
 
    empty_.Signal();
    --inflight_;
 
    TRACE_FLOW_END("flutter", "PipelineItem", trace_id);
    TRACE_EVENT_ASYNC_END0("flutter", "PipelineItem", trace_id);
 
    return items_count > 0 ? PipelineConsumeResult::MoreAvailable
                           : PipelineConsumeResult::Done;
  }

IsValid()

template<class R >

bool flutter::Pipeline< R >::IsValid ( ) const

inline

Definition at line 136 of file pipeline.h.

{ return empty_.IsValid() && available_.IsValid(); }

Produce()

template<class R >

ProducerContinuation flutter::Pipeline< R >::Produce ( )

inline

Creates a ProducerContinuation that a producer can use to add a resource to the queue.

If the queue is already at its maximum depth, the ProducerContinuation is returned with success = false.

Definition at line 143 of file pipeline.h.

                                 {
    if (!empty_.TryWait()) {
      return {};
    }
    ++inflight_;
    FML_TRACE_COUNTER("flutter", "Pipeline Depth",
                      reinterpret_cast<int64_t>(this),      //
                      "frames in flight", inflight_.load()  //
    );
 
    return ProducerContinuation{
        std::bind(&Pipeline::ProducerCommit, this, std::placeholders::_1,
                  std::placeholders::_2),  // continuation
        GetNextPipelineTraceID()};         // trace id
  }

ProduceIfEmpty()

template<class R >

ProducerContinuation flutter::Pipeline< R >::ProduceIfEmpty ( )

inline

Creates a ProducerContinuation that will only push the task if the queue is empty.

Prefer using |Produce|. ProducerContinuation returned by this method doesn't guarantee that the frame will be rendered.

Definition at line 164 of file pipeline.h.

                                        {
    if (!empty_.TryWait()) {
      return {};
    }
    ++inflight_;
    FML_TRACE_COUNTER("flutter", "Pipeline Depth",
                      reinterpret_cast<int64_t>(this),      //
                      "frames in flight", inflight_.load()  //
    );
 
    return ProducerContinuation{
        std::bind(&Pipeline::ProducerCommitIfEmpty, this, std::placeholders::_1,
                  std::placeholders::_2),  // continuation
        GetNextPipelineTraceID()};         // trace id
  }

---

The documentation for this class was generated from the following file:

• shell/common/pipeline.h