#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/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/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 dependency graph for mutex.cc:

Classes
struct	absl::MuHowS

struct	absl::SynchEvent

struct	absl::SynchLocksHeld

struct	absl::SynchWaitParams

Namespaces
	absl

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 }

enum

enum

enum

enum	absl::@339::DelayMode

Functions
	absl::ABSL_XRAY_LOG_ARGS (1) void Mutex

ABSL_ATTRIBUTE_WEAK void	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 void	absl::CondVarEnqueue (SynchWaitParams *waitp)

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

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

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 int	absl::Delay (int32_t c, DelayMode mode)

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) LOCKS_EXCLUDED(deadlock_graph_mu)

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

static PerThreadSynch *	absl::GetPerThreadSynch (intptr_t v)

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

static GraphCycles *deadlock_graph	absl::GUARDED_BY (deadlock_graph_mu) PT_GUARDED_BY(deadlock_graph_mu)

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

int refcount	GUARDED_BY (synch_event_mu)

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::MuSameCondition (PerThreadSynch x, PerThreadSynch y)

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_timestamp))

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)

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
void *	arg

static absl::base_internal::SpinLock	absl::deadlock_graph_mu (absl::base_internal::kLinkerInitialized)

struct {
int absl::flags

const char * absl::msg

}	absl::event_properties []

struct absl::SynchWaitParams	absl::GUARDED_BY [kNSynchEvent]

static const intptr_t	absl::ignore_waiting_writers []

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

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 const 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

char	name [1]

static absl::base_internal::SpinLock	absl::synch_event_mu (absl::base_internal::kLinkerInitialized)

static const intptr_t	absl::zap_desig_waker []

Macro Definition Documentation

◆ __tsan_read1

#define __tsan_read1 ( addr )

Definition at line 2675 of file 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)

Definition at line 1867 of file mutex.cc.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Definition at line 220 of file mutex.cc.

◆ anonymous enum

anonymous enum

Definition at line 240 of file mutex.cc.

◆ anonymous enum

anonymous enum

Definition at line 1282 of file mutex.cc.

◆ DelayMode

enum absl::@339::DelayMode

Definition at line 144 of file mutex.cc.

Function Documentation

◆ AbslInternalMutexYield()

ABSL_ATTRIBUTE_WEAK void AbslInternalMutexYield ( )

Definition at line 70 of file mutex.cc.

◆ GUARDED_BY()

SynchEvent *next GUARDED_BY ( synch_event_mu )

Variable Documentation

◆ arg

void* arg

Definition at line 292 of file mutex.cc.

◆ b

DeadlockReportBuffers* b

Definition at line 1297 of file mutex.cc.

◆ buf

char buf[6100]

Definition at line 1287 of file mutex.cc.

◆ invariant

void(* invariant) (void *arg)

Definition at line 291 of file mutex.cc.

◆ log

bool log

Definition at line 293 of file mutex.cc.

◆ masked_addr

uintptr_t masked_addr

Definition at line 286 of file mutex.cc.

◆ name

char name[1]

Definition at line 296 of file mutex.cc.

◆ num_cpus

int num_cpus

Definition at line 100 of file mutex.cc.

◆ padding

char padding[ABSL_CACHELINE_SIZE - 2 *sizeof(int)]

Definition at line 103 of file mutex.cc.

◆ path

GraphId path[kMaxDeadlockPathLen]

Definition at line 1288 of file mutex.cc.

◆ spinloop_iterations

int spinloop_iterations

Definition at line 101 of file mutex.cc.

Classes

Namespaces

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ __tsan_read1

◆ RAW_CHECK_FMT

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ DelayMode

Function Documentation

◆ AbslInternalMutexYield()

◆ GUARDED_BY()

Variable Documentation

◆ arg

◆ b

◆ buf

◆ invariant

◆ log

◆ masked_addr

◆ name

◆ num_cpus

◆ padding

◆ path

◆ spinloop_iterations