#include "absl/synchronization/mutex.h"
#include <fcntl.h>
#include <pthread.h>
#include <sched.h>
#include <sys/time.h>
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <algorithm>
#include <atomic>
#include <cinttypes>
#include <thread>
#include "absl/base/attributes.h"
#include "absl/base/call_once.h"
#include "absl/base/config.h"
#include "absl/base/dynamic_annotations.h"
#include "absl/base/internal/atomic_hook.h"
#include "absl/base/internal/cycleclock.h"
#include "absl/base/internal/hide_ptr.h"
#include "absl/base/internal/low_level_alloc.h"
#include "absl/base/internal/raw_logging.h"
#include "absl/base/internal/spinlock.h"
#include "absl/base/internal/sysinfo.h"
#include "absl/base/internal/thread_identity.h"
#include "absl/base/internal/tsan_mutex_interface.h"
#include "absl/base/port.h"
#include "absl/debugging/stacktrace.h"
#include "absl/debugging/symbolize.h"
#include "absl/synchronization/internal/graphcycles.h"
#include "absl/synchronization/internal/per_thread_sem.h"
#include "absl/time/time.h"

Include dependency graph for abseil-cpp/absl/synchronization/mutex.cc:

Classes
struct	absl::MuHowS

struct	absl::SynchEvent

struct	absl::SynchLocksHeld

struct	absl::SynchWaitParams

Namespaces
	absl

	absl::ABSL_NAMESPACE_BEGIN

	absl::synchronization_internal

Macros
#define	__tsan_read1(addr)

#define	RAW_CHECK_FMT(cond, ...)

Enumerations
enum	{ absl::kGdbMuSpin = kMuSpin, absl::kGdbMuEvent = kMuEvent, absl::kGdbMuWait = kMuWait, absl::kGdbMuWriter = kMuWriter, absl::kGdbMuDesig = kMuDesig, absl::kGdbMuWrWait = kMuWrWait, absl::kGdbMuReader = kMuReader, absl::kGdbMuLow = kMuLow }

enum	{ absl::kGdbCvSpin = kCvSpin, absl::kGdbCvEvent = kCvEvent, absl::kGdbCvLow = kCvLow }

Functions
static ABSL_CONST_INIT GraphCycles *deadlock_graph	absl::ABSL_GUARDED_BY (deadlock_graph_mu) ABSL_PT_GUARDED_BY(deadlock_graph_mu)

static struct absl::SynchEvent	absl::ABSL_GUARDED_BY (synch_event_mu)

int refcount	ABSL_GUARDED_BY (synch_event_mu)

	absl::ABSL_XRAY_LOG_ARGS (1) void Mutex

ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL()	AbslInternalMutexYield ()

static void	absl::AtomicClearBits (std::atomic< intptr_t > *pv, intptr_t bits, intptr_t wait_until_clear)

static void	absl::AtomicSetBits (std::atomic< intptr_t > *pv, intptr_t bits, intptr_t wait_until_clear)

static void	absl::CheckForMutexCorruption (intptr_t v, const char *label)

static intptr_t	absl::ClearDesignatedWakerMask (int flag)

static void	absl::CondVarEnqueue (SynchWaitParams *waitp)

static char *	absl::CurrentStackString (char *buf, int maxlen, bool symbolize)

static absl::Time	absl::DeadlineFromTimeout (absl::Duration timeout)

static ABSL_CONST_INIT absl::base_internal::SpinLock	absl::deadlock_graph_mu (absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY)

static GraphId	absl::DeadlockCheck (Mutex *mu)

static GraphId	absl::DebugOnlyDeadlockCheck (Mutex *mu)

static bool	absl::DebugOnlyIsExiting ()

static void	absl::DebugOnlyLockEnter (Mutex *mu)

static void	absl::DebugOnlyLockEnter (Mutex *mu, GraphId id)

static void	absl::DebugOnlyLockLeave (Mutex *mu)

static void	absl::DeleteSynchEvent (SynchEvent *e)

static PerThreadSynch *	absl::Dequeue (PerThreadSynch head, PerThreadSynch pw)

static PerThreadSynch *	absl::DequeueAllWakeable (PerThreadSynch head, PerThreadSynch pw, PerThreadSynch **wake_tail)

static bool	absl::Dereference (void *arg)

void	absl::EnableMutexInvariantDebugging (bool enabled)

static PerThreadSynch *	absl::Enqueue (PerThreadSynch head, SynchWaitParams waitp, intptr_t mu, int flags)

static SynchEvent *	absl::EnsureSynchEvent (std::atomic< intptr_t > addr, const char name, intptr_t bits, intptr_t lockbit)

static bool	absl::EvalConditionAnnotated (const Condition cond, Mutex mu, bool locking, bool trylock, bool read_lock)

static bool	absl::EvalConditionIgnored (Mutex mu, const Condition cond)

static bool	absl::ExactlyOneReader (intptr_t v)

static void	absl::FixSkip (PerThreadSynch ancestor, PerThreadSynch to_be_removed)

static void	absl::ForgetSynchEvent (std::atomic< intptr_t > *addr, intptr_t bits, intptr_t lockbit)

static GraphId	absl::GetGraphId (Mutex *mu) ABSL_LOCKS_EXCLUDED(deadlock_graph_mu)

static GraphId	absl::GetGraphIdLocked (Mutex *mu) ABSL_EXCLUSIVE_LOCKS_REQUIRED(deadlock_graph_mu)

static PerThreadSynch *	absl::GetPerThreadSynch (intptr_t v)

static SynchEvent *	absl::GetSynchEvent (const void *addr)

static intptr_t	absl::IgnoreWaitingWritersMask (int flag)

static void	absl::LockEnter (Mutex mu, GraphId id, SynchLocksHeld held_locks)

static void	absl::LockLeave (Mutex mu, GraphId id, SynchLocksHeld held_locks)

static SynchLocksHeld *	absl::LocksHeldAlloc ()

static bool	absl::MuEquivalentWaiter (PerThreadSynch x, PerThreadSynch y)

int	absl::synchronization_internal::MutexDelay (int32_t c, int mode)

static void	absl::PostSynchEvent (void *obj, int ev)

void	absl::RegisterCondVarTracer (void(fn)(const char msg, const void *cv))

void	absl::RegisterMutexProfiler (void(*fn)(int64_t wait_cycles))

void	absl::RegisterMutexTracer (void(fn)(const char msg, const void *obj, int64_t wait_cycles))

void	absl::RegisterSymbolizer (bool(fn)(const void pc, char *out, int out_size))

void	absl::SetMutexDeadlockDetectionMode (OnDeadlockCycle mode)

static PerThreadSynch *	absl::Skip (PerThreadSynch *x)

static char *	absl::StackString (void *pcs, int n, char buf, int maxlen, bool symbolize)

ABSL_CONST_INIT std::atomic< bool >	absl::ABSL_NAMESPACE_BEGIN::synch_check_invariants (false)

ABSL_CONST_INIT std::atomic< OnDeadlockCycle >	absl::ABSL_NAMESPACE_BEGIN::synch_deadlock_detection (kDeadlockDetectionDefault)

static ABSL_CONST_INIT absl::base_internal::SpinLock	absl::synch_event_mu (absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY)

static SynchLocksHeld *	absl::Synch_GetAllLocks ()

static PerThreadSynch *	absl::Synch_GetPerThread ()

static PerThreadSynch *	absl::Synch_GetPerThreadAnnotated (Mutex *mu)

static bool	absl::TryAcquireWithSpinning (std::atomic< intptr_t > *mu)

static void	absl::UnrefSynchEvent (SynchEvent *e)

Variables
struct absl::SynchWaitParams	absl::ABSL_GUARDED_BY [kNSynchEvent]

void *	arg

ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES absl::base_internal::AtomicHook< void()(const char msg, const void *cv)>	absl::ABSL_NAMESPACE_BEGIN::cond_var_tracer

struct {
int absl::flags

const char * absl::msg

}	absl::event_properties []

void(*	invariant )(void *arg)

static const intptr_t	absl::kCvEvent = 0x0002L

static const intptr_t	absl::kCvLow = 0x0003L

static const intptr_t	absl::kCvSpin = 0x0001L

constexpr OnDeadlockCycle	absl::ABSL_NAMESPACE_BEGIN::kDeadlockDetectionDefault = OnDeadlockCycle::kAbort

static constexpr bool	absl::kDebugMode = true

static const Mutex::MuHow	absl::kExclusive = &kExclusiveS

static const MuHowS	absl::kExclusiveS

static const intptr_t	absl::kMuDesig = 0x0002L

static const intptr_t	absl::kMuEvent = 0x0010L

static const int	absl::kMuHasBlocked = 0x01

static const intptr_t	absl::kMuHigh = ~kMuLow

static const int	absl::kMuIsCond = 0x02

static const intptr_t	absl::kMuLow = 0x00ffL

static const intptr_t	absl::kMuOne = 0x0100

static const intptr_t	absl::kMuReader = 0x0001L

static const intptr_t	absl::kMuSpin = 0x0040L

static const intptr_t	absl::kMuWait = 0x0004L

static const intptr_t	absl::kMuWriter = 0x0008L

static const intptr_t	absl::kMuWrWait = 0x0020L

static constexpr uint32_t	absl::kNSynchEvent = 1031

static PerThreadSynch *const	absl::kPerThreadSynchNull

static const Mutex::MuHow	absl::kShared = &kSharedS

static const MuHowS	absl::kSharedS

bool	log

uintptr_t	masked_addr

ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES absl::base_internal::AtomicHook< void()(const char msg, const void *obj, int64_t wait_cycles)>	absl::ABSL_NAMESPACE_BEGIN::mutex_tracer

char	name [1]

ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES absl::base_internal::AtomicHook< void(*)(int64_t wait_cycles)>	absl::ABSL_NAMESPACE_BEGIN::submit_profile_data

ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES absl::base_internal::AtomicHook< bool()(const void pc, char *out, int out_size)>	absl::ABSL_NAMESPACE_BEGIN::symbolizer (absl::Symbolize)

Macro Definition Documentation

◆ __tsan_read1

#define __tsan_read1 ( addr )

Definition at line 2737 of file abseil-cpp/absl/synchronization/mutex.cc.

◆ RAW_CHECK_FMT

#define RAW_CHECK_FMT	(	cond,
		...
	)

Value:

  do {                                                             \
    if (ABSL_PREDICT_FALSE(!(cond))) {                             \
      ABSL_RAW_LOG(FATAL, "Check " #cond " failed: " __VA_ARGS__); \
    }                                                              \
  } while (0)