fml::SharedThreadMerger Class Reference

#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;
}

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;
}

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();
}

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;
}

SetEnabledUnSafe()

void fml::SharedThreadMerger::SetEnabledUnSafe

(

bool

enabled

)

Definition at line 94 of file shared_thread_merger.cc.

                                                      {
  enabled_ = enabled;
}

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;
}

---

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

• fml/shared_thread_merger.h
• fml/shared_thread_merger.cc