#include <shared_thread_merger.h>

Inheritance diagram for fml::SharedThreadMerger:

Public Member Functions
	SharedThreadMerger (TaskQueueId owner, TaskQueueId subsumed)

bool	MergeWithLease (RasterThreadMergerId caller, size_t lease_term)

bool	UnMergeNowIfLastOne (RasterThreadMergerId caller)

void	ExtendLeaseTo (RasterThreadMergerId caller, size_t lease_term)

bool	IsMergedUnSafe () const

bool	IsEnabledUnSafe () const

void	SetEnabledUnSafe (bool enabled)

bool	DecrementLease (RasterThreadMergerId caller)

Public Member Functions inherited from fml::RefCountedThreadSafe< SharedThreadMerger >
void	Release () const

Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void	AddRef () const

bool	HasOneRef () const

void	AssertHasOneRef () const

Additional Inherited Members
Protected Member Functions inherited from fml::RefCountedThreadSafe< SharedThreadMerger >
	RefCountedThreadSafe ()

	~RefCountedThreadSafe ()

Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
	RefCountedThreadSafeBase ()

	~RefCountedThreadSafeBase ()

bool	Release () const

void	Adopt ()

Detailed Description

Instance of this class is shared between multiple |RasterThreadMerger| instances, Most of the callings from |RasterThreadMerger| will be redirected to this class with one more caller parameter.

Definition at line 24 of file shared_thread_merger.h.

Constructor & Destructor Documentation

◆ SharedThreadMerger()

fml::SharedThreadMerger::SharedThreadMerger	(	fml::TaskQueueId	owner,
		fml::TaskQueueId	subsumed
	)

Definition at line 14 of file shared_thread_merger.cc.

    : owner_(owner),
      subsumed_(subsumed),
      task_queues_(fml::MessageLoopTaskQueues::GetInstance()),
      enabled_(true) {}

Member Function Documentation

◆ DecrementLease()

bool fml::SharedThreadMerger::DecrementLease ( RasterThreadMergerId caller )

Definition at line 53 of file shared_thread_merger.cc.

                                                                   {
  std::scoped_lock lock(mutex_);
  auto entry = lease_term_by_caller_.find(caller);
  bool exist = entry != lease_term_by_caller_.end();
  if (exist) {
    std::atomic_size_t& lease_term_ref = entry->second;
    FML_CHECK(lease_term_ref > 0)
        << "lease_term should always be positive when merged, lease_term="
        << lease_term_ref;
    lease_term_ref--;
  } else {
    FML_LOG(WARNING) << "The caller does not exist when calling "
                        "DecrementLease(), ignored. This may happens after "
                        "caller is erased in UnMergeNowIfLastOne(). caller="
                     << caller;
  }
  if (IsAllLeaseTermsZeroUnSafe()) {
    // Unmerge now because lease_term_ decreased to zero.
    UnMergeNowUnSafe();
    return true;
  }
  return false;
}

References FML_CHECK, and FML_LOG.

Referenced by fml::RasterThreadMerger::DecrementLease().

◆ ExtendLeaseTo()

void fml::SharedThreadMerger::ExtendLeaseTo	(	RasterThreadMergerId	caller,
		size_t	lease_term
	)

Definition at line 77 of file shared_thread_merger.cc.

                                                          {
  FML_DCHECK(lease_term > 0) << "lease_term should be positive.";
  std::scoped_lock lock(mutex_);
  FML_DCHECK(IsMergedUnSafe())
      << "should be merged state when calling this method";
  lease_term_by_caller_[caller] = lease_term;
}

References FML_DCHECK, and IsMergedUnSafe().

Referenced by fml::RasterThreadMerger::ExtendLeaseTo().

◆ IsEnabledUnSafe()

bool fml::SharedThreadMerger::IsEnabledUnSafe ( ) const

Definition at line 90 of file shared_thread_merger.cc.

                                               {
  return enabled_;
}

◆ IsMergedUnSafe()

bool fml::SharedThreadMerger::IsMergedUnSafe ( ) const

Definition at line 86 of file shared_thread_merger.cc.

                                              {
  return !IsAllLeaseTermsZeroUnSafe();
}

Referenced by ExtendLeaseTo(), and MergeWithLease().

◆ MergeWithLease()

bool fml::SharedThreadMerger::MergeWithLease	(	RasterThreadMergerId	caller,
		size_t	lease_term
	)

Definition at line 21 of file shared_thread_merger.cc.

                                                           {
  FML_DCHECK(lease_term > 0) << "lease_term should be positive.";
  std::scoped_lock lock(mutex_);
  if (IsMergedUnSafe()) {
    return true;
  }
  bool success = task_queues_->Merge(owner_, subsumed_);
  FML_CHECK(success) << "Unable to merge the raster and platform threads.";
  // Save the lease term
  lease_term_by_caller_[caller] = lease_term;
  return success;
}

References FML_CHECK, FML_DCHECK, IsMergedUnSafe(), and fml::MessageLoopTaskQueues::Merge().

Referenced by fml::RasterThreadMerger::MergeWithLease().

◆ SetEnabledUnSafe()

void fml::SharedThreadMerger::SetEnabledUnSafe ( bool enabled )

Definition at line 94 of file shared_thread_merger.cc.

                                                      {
  enabled_ = enabled;
}

Referenced by fml::RasterThreadMerger::Disable(), and fml::RasterThreadMerger::Enable().

◆ UnMergeNowIfLastOne()

bool fml::SharedThreadMerger::UnMergeNowIfLastOne ( RasterThreadMergerId caller )

Definition at line 44 of file shared_thread_merger.cc.

                                                                        {
  std::scoped_lock lock(mutex_);
  lease_term_by_caller_.erase(caller);
  if (lease_term_by_caller_.empty() || IsAllLeaseTermsZeroUnSafe()) {
    return UnMergeNowUnSafe();
  }
  return true;
}

Referenced by fml::RasterThreadMerger::UnMergeNowIfLastOne().

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

fml/shared_thread_merger.h
fml/shared_thread_merger.cc

Public Member Functions

Additional Inherited Members