#include <cpu.h>

Collaboration diagram for v8::base::FINAL< T, S >:

Public Types
typedef T	flag_type

typedef S	mask_type

typedef Mutex::NativeHandle	NativeHandle

typedef bool(*	EntropySource) (unsigned char *buffer, size_t buflen)

Public Member Functions
	CPU ()

const char *	vendor () const

int	stepping () const

int	model () const

int	ext_model () const

int	family () const

int	ext_family () const

int	type () const

int	implementer () const

int	architecture () const

int	part () const

bool	has_fpu () const

bool	has_cmov () const

bool	has_sahf () const

bool	has_mmx () const

bool	has_sse () const

bool	has_sse2 () const

bool	has_sse3 () const

bool	has_ssse3 () const

bool	has_sse41 () const

bool	has_sse42 () const

bool	has_idiva () const

bool	has_neon () const

bool	has_thumb2 () const

bool	has_vfp () const

bool	has_vfp3 () const

bool	has_vfp3_d32 () const

bool	is_fp64_mode () const

	Flags ()

	Flags (flag_type flag)

	Flags (mask_type mask)

Flags &	operator&= (const Flags &flags)

Flags &	operator\|= (const Flags &flags)

Flags &	operator^= (const Flags &flags)

Flags	operator& (const Flags &flags) const

Flags	operator\| (const Flags &flags) const

Flags	operator^ (const Flags &flags) const

Flags &	operator&= (flag_type flag)

Flags &	operator\|= (flag_type flag)

Flags &	operator^= (flag_type flag)

Flags	operator& (flag_type flag) const

Flags	operator\| (flag_type flag) const

Flags	operator^ (flag_type flag) const

Flags	operator~ () const

	operator mask_type () const

bool	operator! () const

	ConditionVariable ()

	~ConditionVariable ()

void	NotifyOne ()

void	NotifyAll ()

void	Wait (Mutex *mutex)

bool	WaitFor (Mutex *mutex, const TimeDelta &rel_time) WARN_UNUSED_RESULT

NativeHandle &	native_handle ()

const NativeHandle &	native_handle () const

void	Start ()

void	Stop ()

bool	IsStarted () const

TimeDelta	Restart ()

TimeDelta	Elapsed () const

bool	HasExpired (TimeDelta time_delta) const

	Mutex ()

	~Mutex ()

void	Lock ()

void	Unlock ()

bool	TryLock () WARN_UNUSED_RESULT

NativeHandle &	native_handle ()

const NativeHandle &	native_handle () const

	RecursiveMutex ()

	~RecursiveMutex ()

void	Lock ()

void	Unlock ()

bool	TryLock () WARN_UNUSED_RESULT

NativeHandle &	native_handle ()

const NativeHandle &	native_handle () const

	LockGuard (Mutex *mutex)

	~LockGuard ()

	Semaphore (int count)

	~Semaphore ()

void	Signal ()

void	Wait ()

bool	WaitFor (const TimeDelta &rel_time) WARN_UNUSED_RESULT

NativeHandle &	native_handle ()

const NativeHandle &	native_handle () const

	TimeDelta ()

int	InDays () const

int	InHours () const

int	InMinutes () const

double	InSecondsF () const

int64_t	InSeconds () const

double	InMillisecondsF () const

int64_t	InMilliseconds () const

int64_t	InMillisecondsRoundedUp () const

int64_t	InMicroseconds () const

int64_t	InNanoseconds () const

struct mach_timespec	ToMachTimespec () const

struct timespec	ToTimespec () const

TimeDelta &	operator= (const TimeDelta &other)

TimeDelta	operator+ (const TimeDelta &other) const

TimeDelta	operator- (const TimeDelta &other) const

TimeDelta &	operator+= (const TimeDelta &other)

TimeDelta &	operator-= (const TimeDelta &other)

TimeDelta	operator- () const

double	TimesOf (const TimeDelta &other) const

double	PercentOf (const TimeDelta &other) const

TimeDelta	operator* (int64_t a) const

TimeDelta	operator/ (int64_t a) const

TimeDelta &	operator*= (int64_t a)

TimeDelta &	operator/= (int64_t a)

int64_t	operator/ (const TimeDelta &other) const

bool	operator== (const TimeDelta &other) const

bool	operator!= (const TimeDelta &other) const

bool	operator< (const TimeDelta &other) const

bool	operator<= (const TimeDelta &other) const

bool	operator> (const TimeDelta &other) const

bool	operator>= (const TimeDelta &other) const

	Time ()

bool	IsNull () const

bool	IsMax () const

int64_t	ToInternalValue () const

struct timespec	ToTimespec () const

struct timeval	ToTimeval () const

struct _FILETIME	ToFiletime () const

double	ToJsTime () const

Time &	operator= (const Time &other)

TimeDelta	operator- (const Time &other) const

Time &	operator+= (const TimeDelta &delta)

Time &	operator-= (const TimeDelta &delta)

Time	operator+ (const TimeDelta &delta) const

Time	operator- (const TimeDelta &delta) const

bool	operator== (const Time &other) const

bool	operator!= (const Time &other) const

bool	operator< (const Time &other) const

bool	operator<= (const Time &other) const

bool	operator> (const Time &other) const

bool	operator>= (const Time &other) const

	TimeTicks ()

bool	IsNull () const

int64_t	ToInternalValue () const

TimeTicks &	operator= (const TimeTicks other)

TimeDelta	operator- (const TimeTicks other) const

TimeTicks &	operator+= (const TimeDelta &delta)

TimeTicks &	operator-= (const TimeDelta &delta)

TimeTicks	operator+ (const TimeDelta &delta) const

TimeTicks	operator- (const TimeDelta &delta) const

bool	operator== (const TimeTicks &other) const

bool	operator!= (const TimeTicks &other) const

bool	operator< (const TimeTicks &other) const

bool	operator<= (const TimeTicks &other) const

bool	operator> (const TimeTicks &other) const

bool	operator>= (const TimeTicks &other) const

	RandomNumberGenerator ()

	RandomNumberGenerator (int64_t seed)

int	NextInt () WARN_UNUSED_RESULT

int	NextInt (int max) WARN_UNUSED_RESULT

bool	NextBool () WARN_UNUSED_RESULT

double	NextDouble () WARN_UNUSED_RESULT

void	NextBytes (void *buffer, size_t buflen)

void	SetSeed (int64_t seed)

int64_t	initial_seed () const

Static Public Member Functions
static TimeDelta	FromDays (int days)

static TimeDelta	FromHours (int hours)

static TimeDelta	FromMinutes (int minutes)

static TimeDelta	FromSeconds (int64_t seconds)

static TimeDelta	FromMilliseconds (int64_t milliseconds)

static TimeDelta	FromMicroseconds (int64_t microseconds)

static TimeDelta	FromNanoseconds (int64_t nanoseconds)

static TimeDelta	FromMachTimespec (struct mach_timespec ts)

static TimeDelta	FromTimespec (struct timespec ts)

static Time	Now ()

static Time	NowFromSystemTime ()

static Time	UnixEpoch ()

static Time	Max ()

static Time	FromInternalValue (int64_t value)

static Time	FromTimespec (struct timespec ts)

static Time	FromTimeval (struct timeval tv)

static Time	FromFiletime (struct _FILETIME ft)

static Time	FromJsTime (double ms_since_epoch)

static TimeTicks	Now ()

static TimeTicks	HighResolutionNow ()

static bool	IsHighResolutionClockWorking ()

static TimeTicks	KernelTimestampNow ()

static bool	KernelTimestampAvailable ()

static TimeTicks	FromInternalValue (int64_t value)

static int	NumberOfProcessors ()

static int64_t	AmountOfPhysicalMemory ()

static int64_t	AmountOfVirtualMemory ()

static void	SetEntropySource (EntropySource entropy_source)

Static Public Attributes
static const int	ARM = 0x41

static const int	NVIDIA = 0x4e

static const int	QUALCOMM = 0x51

static const int	ARM_CORTEX_A5 = 0xc05

static const int	ARM_CORTEX_A7 = 0xc07

static const int	ARM_CORTEX_A8 = 0xc08

static const int	ARM_CORTEX_A9 = 0xc09

static const int	ARM_CORTEX_A12 = 0xc0c

static const int	ARM_CORTEX_A15 = 0xc0f

static const int64_t	kMillisecondsPerSecond = 1000

static const int64_t	kMicrosecondsPerMillisecond = 1000

static const int64_t	kMicrosecondsPerSecond

static const int64_t	kMicrosecondsPerMinute = kMicrosecondsPerSecond * 60

static const int64_t	kMicrosecondsPerHour = kMicrosecondsPerMinute * 60

static const int64_t	kMicrosecondsPerDay = kMicrosecondsPerHour * 24

static const int64_t	kMicrosecondsPerWeek = kMicrosecondsPerDay * 7

static const int64_t	kNanosecondsPerMicrosecond = 1000

static const int64_t	kNanosecondsPerSecond

Private Member Functions
	DISALLOW_COPY_AND_ASSIGN (ConditionVariable)

void	AssertHeldAndUnmark ()

void	AssertUnheldAndMark ()

	DISALLOW_COPY_AND_ASSIGN (Mutex)

	DISALLOW_COPY_AND_ASSIGN (RecursiveMutex)

	DISALLOW_COPY_AND_ASSIGN (LockGuard)

	DISALLOW_COPY_AND_ASSIGN (Semaphore)

	TimeDelta (int64_t delta)

	Time (int64_t us)

	TimeTicks (int64_t ticks)

int	Next (int bits) WARN_UNUSED_RESULT

Static Private Member Functions
static TimeTicks	Now ()

Private Attributes
char	vendor_ [13]

int	stepping_

int	model_

int	ext_model_

int	family_

int	ext_family_

int	type_

int	implementer_

int	architecture_

int	part_

bool	has_fpu_

bool	has_cmov_

bool	has_sahf_

bool	has_mmx_

bool	has_sse_

bool	has_sse2_

bool	has_sse3_

bool	has_ssse3_

bool	has_sse41_

bool	has_sse42_

bool	has_idiva_

bool	has_neon_

bool	has_thumb2_

bool	has_vfp_

bool	has_vfp3_

bool	has_vfp3_d32_

bool	is_fp64_mode_

mask_type	mask_

NativeHandle	native_handle_

TimeTicks	start_ticks_

Mutex *	mutex_

int64_t	delta_

int64_t	us_

int64_t	ticks_

int64_t	initial_seed_

int64_t	seed_

Static Private Attributes
static const int64_t	kMultiplier = V8_2PART_UINT64_C(0x5, deece66d)

static const int64_t	kAddend = 0xb

static const int64_t	kMask = V8_2PART_UINT64_C(0xffff, ffffffff)

Friends
class	ConditionVariable

Detailed Description

template<typename T, typename S = int>
class v8::base::FINAL< T, S >

Definition at line 31 of file cpu.h.

Member Typedef Documentation

◆ EntropySource

template<typename T , typename S = int>

typedef bool(* v8::base::FINAL< T, S >::EntropySource) (unsigned char *buffer, size_t buflen)

Definition at line 32 of file random-number-generator.h.

◆ flag_type

template<typename T , typename S = int>

typedef T v8::base::FINAL< T, S >::flag_type

Definition at line 25 of file flags.h.

◆ mask_type

template<typename T , typename S = int>

typedef S v8::base::FINAL< T, S >::mask_type

Definition at line 26 of file flags.h.

◆ NativeHandle

template<typename T , typename S = int>

typedef Mutex::NativeHandle v8::base::FINAL< T, S >::NativeHandle

Definition at line 155 of file mutex.h.

Constructor & Destructor Documentation

◆ ~ConditionVariable()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::~ConditionVariable ( )

◆ ~Mutex()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::~Mutex ( )

◆ ~RecursiveMutex()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::~RecursiveMutex ( )

◆ ~LockGuard()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::~LockGuard ( )

inline

Definition at line 205 of file mutex.h.

205 { mutex_->Unlock(); }

v8::base::FINAL::mutex_

Mutex * mutex_

Definition: mutex.h:208

◆ ~Semaphore()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::~Semaphore ( )

Member Function Documentation

◆ AmountOfPhysicalMemory()

template<typename T , typename S = int>

static int64_t v8::base::FINAL< T, S >::AmountOfPhysicalMemory ( )

static

◆ AmountOfVirtualMemory()

template<typename T , typename S = int>

static int64_t v8::base::FINAL< T, S >::AmountOfVirtualMemory ( )

static

◆ architecture()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::architecture ( ) const

inline

Definition at line 49 of file cpu.h.

49 { return architecture_; }

v8::base::FINAL::architecture_

int architecture_

Definition: cpu.h:92

◆ AssertHeldAndUnmark()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::AssertHeldAndUnmark ( )

inlineprivate

Definition at line 75 of file mutex.h.

                                        {
 #ifdef DEBUG
     DCHECK_EQ(1, level_);
     level_--;
 #endif
   }

References DCHECK_EQ.

◆ AssertUnheldAndMark()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::AssertUnheldAndMark ( )

inlineprivate

Definition at line 82 of file mutex.h.

                                        {
 #ifdef DEBUG
     DCHECK_EQ(0, level_);
     level_++;
 #endif
   }

References DCHECK_EQ.

◆ ConditionVariable()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::ConditionVariable ( )

◆ CPU()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::CPU ( )

◆ DISALLOW_COPY_AND_ASSIGN() [1/5]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::DISALLOW_COPY_AND_ASSIGN ( ConditionVariable )

private

◆ DISALLOW_COPY_AND_ASSIGN() [2/5]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::DISALLOW_COPY_AND_ASSIGN ( LockGuard )

private

◆ DISALLOW_COPY_AND_ASSIGN() [3/5]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::DISALLOW_COPY_AND_ASSIGN ( Mutex )

private

◆ DISALLOW_COPY_AND_ASSIGN() [4/5]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::DISALLOW_COPY_AND_ASSIGN ( RecursiveMutex )

private

◆ DISALLOW_COPY_AND_ASSIGN() [5/5]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::DISALLOW_COPY_AND_ASSIGN ( Semaphore )

private

◆ Elapsed()

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::Elapsed ( ) const

inline

Definition at line 67 of file elapsed-timer.h.

                             {
     DCHECK(IsStarted());
     TimeDelta elapsed = Now() - start_ticks_;
     DCHECK(elapsed.InMicroseconds() >= 0);
     return elapsed;
   }

References DCHECK.

◆ ext_family()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::ext_family ( ) const

inline

Definition at line 41 of file cpu.h.

41 { return ext_family_; }

v8::base::FINAL::ext_family_

int ext_family_

Definition: cpu.h:89

◆ ext_model()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::ext_model ( ) const

inline

Definition at line 39 of file cpu.h.

39 { return ext_model_; }

v8::base::FINAL::ext_model_

int ext_model_

Definition: cpu.h:87

◆ family()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::family ( ) const

inline

Definition at line 40 of file cpu.h.

40 { return family_; }

v8::base::FINAL::family_

int family_

Definition: cpu.h:88

◆ Flags() [1/3]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::Flags ( )

inline

Definition at line 28 of file flags.h.

28 : mask_(0) {}

v8::base::FINAL::mask_

mask_type mask_

Definition: flags.h:63

◆ Flags() [2/3]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::Flags ( flag_type flag )

inline

Definition at line 29 of file flags.h.

29 : mask_(flag) {} // NOLINT(runtime/explicit)

v8::internal::flag

kFeedbackVectorOffset flag

Definition: objects-inl.h:5418

◆ Flags() [3/3]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::Flags ( mask_type mask )

inlineexplicit

Definition at line 30 of file flags.h.

30 : mask_(mask) {}

◆ FromDays()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromDays ( int days )

static

◆ FromFiletime()

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::FromFiletime ( struct _FILETIME ft )

static

◆ FromHours()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromHours ( int hours )

static

◆ FromInternalValue() [1/2]

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::FromInternalValue ( int64_t value )

inlinestatic

Definition at line 204 of file time.h.

                                                {
     return Time(value);
   }

◆ FromInternalValue() [2/2]

template<typename T , typename S = int>

static TimeTicks v8::base::FINAL< T, S >::FromInternalValue ( int64_t value )

inlinestatic

Definition at line 330 of file time.h.

                                                     {
     return TimeTicks(value);
   }

◆ FromJsTime()

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::FromJsTime ( double ms_since_epoch )

static

◆ FromMachTimespec()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromMachTimespec ( struct mach_timespec ts )

static

◆ FromMicroseconds()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromMicroseconds ( int64_t microseconds )

inlinestatic

Definition at line 43 of file time.h.

                                                           {
     return TimeDelta(microseconds);
   }

◆ FromMilliseconds()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromMilliseconds ( int64_t milliseconds )

static

◆ FromMinutes()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromMinutes ( int minutes )

static

◆ FromNanoseconds()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromNanoseconds ( int64_t nanoseconds )

static

◆ FromSeconds()

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromSeconds ( int64_t seconds )

static

◆ FromTimespec() [1/2]

template<typename T , typename S = int>

static TimeDelta v8::base::FINAL< T, S >::FromTimespec ( struct timespec ts )

static

◆ FromTimespec() [2/2]

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::FromTimespec ( struct timespec ts )

static

◆ FromTimeval()

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::FromTimeval ( struct timeval tv )

static

◆ has_cmov()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_cmov ( ) const

inline

Definition at line 62 of file cpu.h.

62 { return has_cmov_; }

v8::base::FINAL::has_cmov_

bool has_cmov_

Definition: cpu.h:95

◆ has_fpu()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_fpu ( ) const

inline

Definition at line 59 of file cpu.h.

59 { return has_fpu_; }

v8::base::FINAL::has_fpu_

bool has_fpu_

Definition: cpu.h:94

◆ has_idiva()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_idiva ( ) const

inline

Definition at line 73 of file cpu.h.

73 { return has_idiva_; }

v8::base::FINAL::has_idiva_

bool has_idiva_

Definition: cpu.h:104

◆ has_mmx()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_mmx ( ) const

inline

Definition at line 64 of file cpu.h.

64 { return has_mmx_; }

v8::base::FINAL::has_mmx_

bool has_mmx_

Definition: cpu.h:97

◆ has_neon()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_neon ( ) const

inline

Definition at line 74 of file cpu.h.

74 { return has_neon_; }

v8::base::FINAL::has_neon_

bool has_neon_

Definition: cpu.h:105

◆ has_sahf()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sahf ( ) const

inline

Definition at line 63 of file cpu.h.

63 { return has_sahf_; }

v8::base::FINAL::has_sahf_

bool has_sahf_

Definition: cpu.h:96

◆ has_sse()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse ( ) const

inline

Definition at line 65 of file cpu.h.

65 { return has_sse_; }

v8::base::FINAL::has_sse_

bool has_sse_

Definition: cpu.h:98

◆ has_sse2()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse2 ( ) const

inline

Definition at line 66 of file cpu.h.

66 { return has_sse2_; }

v8::base::FINAL::has_sse2_

bool has_sse2_

Definition: cpu.h:99

◆ has_sse3()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse3 ( ) const

inline

Definition at line 67 of file cpu.h.

67 { return has_sse3_; }

v8::base::FINAL::has_sse3_

bool has_sse3_

Definition: cpu.h:100

◆ has_sse41()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse41 ( ) const

inline

Definition at line 69 of file cpu.h.

69 { return has_sse41_; }

v8::base::FINAL::has_sse41_

bool has_sse41_

Definition: cpu.h:102

◆ has_sse42()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse42 ( ) const

inline

Definition at line 70 of file cpu.h.

70 { return has_sse42_; }

v8::base::FINAL::has_sse42_

bool has_sse42_

Definition: cpu.h:103

◆ has_ssse3()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_ssse3 ( ) const

inline

Definition at line 68 of file cpu.h.

68 { return has_ssse3_; }

v8::base::FINAL::has_ssse3_

bool has_ssse3_

Definition: cpu.h:101

◆ has_thumb2()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_thumb2 ( ) const

inline

Definition at line 75 of file cpu.h.

75 { return has_thumb2_; }

v8::base::FINAL::has_thumb2_

bool has_thumb2_

Definition: cpu.h:106

◆ has_vfp()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_vfp ( ) const

inline

Definition at line 76 of file cpu.h.

76 { return has_vfp_; }

v8::base::FINAL::has_vfp_

bool has_vfp_

Definition: cpu.h:107

◆ has_vfp3()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_vfp3 ( ) const

inline

Definition at line 77 of file cpu.h.

77 { return has_vfp3_; }

v8::base::FINAL::has_vfp3_

bool has_vfp3_

Definition: cpu.h:108

◆ has_vfp3_d32()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_vfp3_d32 ( ) const

inline

Definition at line 78 of file cpu.h.

78 { return has_vfp3_d32_; }

v8::base::FINAL::has_vfp3_d32_

bool has_vfp3_d32_

Definition: cpu.h:109

◆ HasExpired()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::HasExpired ( TimeDelta time_delta ) const

inline

Definition at line 77 of file elapsed-timer.h.

                                               {
     DCHECK(IsStarted());
     return Elapsed() >= time_delta;
   }

References DCHECK.

◆ HighResolutionNow()

template<typename T , typename S = int>

static TimeTicks v8::base::FINAL< T, S >::HighResolutionNow ( )

static

◆ implementer()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::implementer ( ) const

inline

Definition at line 45 of file cpu.h.

45 { return implementer_; }

v8::base::FINAL::implementer_

int implementer_

Definition: cpu.h:91

◆ InDays()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::InDays ( ) const

◆ InHours()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::InHours ( ) const

◆ initial_seed()

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::initial_seed ( ) const

inline

Definition at line 77 of file random-number-generator.h.

77 { return initial_seed_; }

v8::base::FINAL::initial_seed_

int64_t initial_seed_

Definition: random-number-generator.h:86

◆ InMicroseconds()

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::InMicroseconds ( ) const

inline

Definition at line 61 of file time.h.

61 { return delta_; }

v8::base::FINAL::delta_

int64_t delta_

Definition: time.h:151

◆ InMilliseconds()

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::InMilliseconds ( ) const

◆ InMillisecondsF()

template<typename T , typename S = int>

double v8::base::FINAL< T, S >::InMillisecondsF ( ) const

◆ InMillisecondsRoundedUp()

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::InMillisecondsRoundedUp ( ) const

◆ InMinutes()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::InMinutes ( ) const

◆ InNanoseconds()

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::InNanoseconds ( ) const

◆ InSeconds()

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::InSeconds ( ) const

◆ InSecondsF()

template<typename T , typename S = int>

double v8::base::FINAL< T, S >::InSecondsF ( ) const

◆ is_fp64_mode()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::is_fp64_mode ( ) const

inline

Definition at line 81 of file cpu.h.

81 { return is_fp64_mode_; }

v8::base::FINAL::is_fp64_mode_

bool is_fp64_mode_

Definition: cpu.h:110

◆ IsHighResolutionClockWorking()

template<typename T , typename S = int>

static bool v8::base::FINAL< T, S >::IsHighResolutionClockWorking ( )

static

◆ IsMax()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::IsMax ( ) const

inline

Definition at line 182 of file time.h.

182 { return us_ == std::numeric_limits<int64_t>::max(); }

v8::base::FINAL::us_

int64_t us_

Definition: time.h:280

◆ IsNull() [1/2]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::IsNull ( ) const

inline

Definition at line 179 of file time.h.

179 { return us_ == 0; }

◆ IsNull() [2/2]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::IsNull ( ) const

inline

Definition at line 326 of file time.h.

326 { return ticks_ == 0; }

v8::base::FINAL::ticks_

int64_t ticks_

Definition: time.h:391

◆ IsStarted()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::IsStarted ( ) const

inline

Definition at line 44 of file elapsed-timer.h.

                          {
     DCHECK(started_ || start_ticks_.IsNull());
     DCHECK(!started_ || !start_ticks_.IsNull());
     return !start_ticks_.IsNull();
   }

References DCHECK.

◆ KernelTimestampAvailable()

template<typename T , typename S = int>

static bool v8::base::FINAL< T, S >::KernelTimestampAvailable ( )

static

◆ KernelTimestampNow()

template<typename T , typename S = int>

static TimeTicks v8::base::FINAL< T, S >::KernelTimestampNow ( )

static

◆ Lock() [1/2]

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Lock ( )

◆ Lock() [2/2]

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Lock ( )

◆ LockGuard()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::LockGuard ( Mutex * mutex )

inlineexplicit

Definition at line 204 of file mutex.h.

204 : mutex_(mutex) { mutex_->Lock(); }

◆ Max()

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::Max ( )

inlinestatic

Definition at line 200 of file time.h.

200 { return Time(std::numeric_limits<int64_t>::max()); }

◆ model()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::model ( ) const

inline

Definition at line 38 of file cpu.h.

38 { return model_; }

v8::base::FINAL::model_

int model_

Definition: cpu.h:86

◆ Mutex()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::Mutex ( )

◆ native_handle() [1/8]

template<typename T , typename S = int>

NativeHandle& v8::base::FINAL< T, S >::native_handle ( )

inline

Definition at line 86 of file condition-variable.h.

                                 {
     return native_handle_;
   }

◆ native_handle() [2/8]

template<typename T , typename S = int>

NativeHandle& v8::base::FINAL< T, S >::native_handle ( )

inline

Definition at line 62 of file mutex.h.

                                 {
     return native_handle_;
   }

◆ native_handle() [3/8]

template<typename T , typename S = int>

NativeHandle& v8::base::FINAL< T, S >::native_handle ( )

inline

Definition at line 157 of file mutex.h.

                                 {
     return native_handle_;
   }

◆ native_handle() [4/8]

template<typename T , typename S = int>

NativeHandle& v8::base::FINAL< T, S >::native_handle ( )

inline

Definition at line 60 of file semaphore.h.

                                 {
     return native_handle_;
   }

◆ native_handle() [5/8]

template<typename T , typename S = int>

const NativeHandle& v8::base::FINAL< T, S >::native_handle ( ) const

inline

Definition at line 89 of file condition-variable.h.

                                             {
     return native_handle_;
   }

◆ native_handle() [6/8]

template<typename T , typename S = int>

const NativeHandle& v8::base::FINAL< T, S >::native_handle ( ) const

inline

Definition at line 65 of file mutex.h.

                                             {
     return native_handle_;
   }

◆ native_handle() [7/8]

template<typename T , typename S = int>

const NativeHandle& v8::base::FINAL< T, S >::native_handle ( ) const

inline

Definition at line 160 of file mutex.h.

                                             {
     return native_handle_;
   }

◆ native_handle() [8/8]

template<typename T , typename S = int>

const NativeHandle& v8::base::FINAL< T, S >::native_handle ( ) const

inline

Definition at line 63 of file semaphore.h.

                                             {
     return native_handle_;
   }

◆ Next()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::Next ( int bits )

private

◆ NextBool()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::NextBool ( )

inline

Definition at line 60 of file random-number-generator.h.

                                                {
     return Next(1) != 0;
   }

◆ NextBytes()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::NextBytes	(	void *	buffer,
		size_t	buflen
	)

◆ NextDouble()

template<typename T , typename S = int>

double v8::base::FINAL< T, S >::NextDouble ( )

◆ NextInt() [1/2]

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::NextInt ( )

inline

Definition at line 43 of file random-number-generator.h.

                                              {
     return Next(32);
   }

◆ NextInt() [2/2]

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::NextInt ( int max )

◆ NotifyAll()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::NotifyAll ( )

◆ NotifyOne()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::NotifyOne ( )

◆ Now() [1/3]

template<typename T , typename S = int>

static TimeTicks v8::base::FINAL< T, S >::Now ( )

inlinestaticprivate

Definition at line 83 of file elapsed-timer.h.

                                    {
     TimeTicks now = TimeTicks::HighResolutionNow();
     DCHECK(!now.IsNull());
     return now;
   }

References DCHECK.

◆ Now() [2/3]

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::Now ( )

static

◆ Now() [3/3]

template<typename T , typename S = int>

static TimeTicks v8::base::FINAL< T, S >::Now ( )

static

◆ NowFromSystemTime()

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::NowFromSystemTime ( )

static

◆ NumberOfProcessors()

template<typename T , typename S = int>

static int v8::base::FINAL< T, S >::NumberOfProcessors ( )

static

◆ operator mask_type()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::operator mask_type ( ) const

inline

Definition at line 59 of file flags.h.

59 { return mask_; }

◆ operator!()

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator! ( ) const

inline

Definition at line 60 of file flags.h.

60 { return !mask_; }

◆ operator!=() [1/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator!= ( const Time & other ) const

inline

Definition at line 260 of file time.h.

                                            {
     return us_ != other.us_;
   }

◆ operator!=() [2/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator!= ( const TimeDelta & other ) const

inline

Definition at line 128 of file time.h.

                                                 {
     return delta_ != other.delta_;
   }

◆ operator!=() [3/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator!= ( const TimeTicks & other ) const

inline

Definition at line 369 of file time.h.

                                                 {
     return ticks_ != other.ticks_;
   }

◆ operator&() [1/2]

template<typename T , typename S = int>

Flags v8::base::FINAL< T, S >::operator& ( const Flags & flags ) const

inline

Definition at line 45 of file flags.h.

45 { return Flags(*this) &= flags; }

v8::base::FINAL::Flags

Flags()

Definition: flags.h:28

v8::internal::anonymous_namespace{flags.cc}::flags

Flag flags[]

Definition: flags.cc:160

References v8::internal::anonymous_namespace{flags.cc}::flags.

◆ operator&() [2/2]

template<typename T , typename S = int>

Flags v8::base::FINAL< T, S >::operator& ( flag_type flag ) const

inline

Definition at line 53 of file flags.h.

53 { return operator&(Flags(flag)); }

v8::base::FINAL::operator&

Flags operator&(const Flags &flags) const

Definition: flags.h:45

References v8::internal::flag, and v8::base::FINAL< T, S >::operator&().

Referenced by v8::base::FINAL< T, S >::operator&().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator&=() [1/2]

template<typename T , typename S = int>

Flags& v8::base::FINAL< T, S >::operator&= ( const Flags & flags )

inline

Definition at line 32 of file flags.h.

                                         {
     mask_ &= flags.mask_;
     return *this;
   }

References v8::internal::anonymous_namespace{flags.cc}::flags.

◆ operator&=() [2/2]

template<typename T , typename S = int>

Flags& v8::base::FINAL< T, S >::operator&= ( flag_type flag )

inline

Definition at line 49 of file flags.h.

49 { return operator&=(Flags(flag)); }

v8::base::FINAL::operator&=

Flags & operator&=(const Flags &flags)

Definition: flags.h:32

References v8::internal::flag, and v8::base::FINAL< T, S >::operator&=().

Referenced by v8::base::FINAL< T, S >::operator&=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator*()

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::operator* ( int64_t a ) const

inline

Definition at line 106 of file time.h.

                                        {
     return TimeDelta(delta_ * a);
   }

◆ operator*=()

template<typename T , typename S = int>

TimeDelta& v8::base::FINAL< T, S >::operator*= ( int64_t a )

inline

Definition at line 112 of file time.h.

                                    {
     delta_ *= a;
     return *this;
   }

◆ operator+() [1/3]

template<typename T , typename S = int>

Time v8::base::FINAL< T, S >::operator+ ( const TimeDelta & delta ) const

inline

Definition at line 249 of file time.h.

                                                {
     return Time(us_ + delta.InMicroseconds());
   }

◆ operator+() [2/3]

template<typename T , typename S = int>

TimeTicks v8::base::FINAL< T, S >::operator+ ( const TimeDelta & delta ) const

inline

Definition at line 358 of file time.h.

                                                     {
     return TimeTicks(ticks_ + delta.InMicroseconds());
   }

◆ operator+() [3/3]

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::operator+ ( const TimeDelta & other ) const

inline

Definition at line 78 of file time.h.

                                                     {
     return TimeDelta(delta_ + other.delta_);
   }

◆ operator+=() [1/3]

template<typename T , typename S = int>

Time& v8::base::FINAL< T, S >::operator+= ( const TimeDelta & delta )

inline

Definition at line 239 of file time.h.

                                            {
     us_ += delta.InMicroseconds();
     return *this;
   }

◆ operator+=() [2/3]

template<typename T , typename S = int>

TimeTicks& v8::base::FINAL< T, S >::operator+= ( const TimeDelta & delta )

inline

Definition at line 348 of file time.h.

                                                 {
     ticks_ += delta.InMicroseconds();
     return *this;
   }

◆ operator+=() [3/3]

template<typename T , typename S = int>

TimeDelta& v8::base::FINAL< T, S >::operator+= ( const TimeDelta & other )

inline

Definition at line 85 of file time.h.

                                                 {
     delta_ += other.delta_;
     return *this;
   }

◆ operator-() [1/6]

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::operator- ( ) const

inline

Definition at line 93 of file time.h.

                               {
     return TimeDelta(-delta_);
   }

◆ operator-() [2/6]

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::operator- ( const Time & other ) const

inline

Definition at line 234 of file time.h.

                                                {
     return TimeDelta::FromMicroseconds(us_ - other.us_);
   }

◆ operator-() [3/6]

template<typename T , typename S = int>

Time v8::base::FINAL< T, S >::operator- ( const TimeDelta & delta ) const

inline

Definition at line 252 of file time.h.

                                                {
     return Time(us_ - delta.InMicroseconds());
   }

◆ operator-() [4/6]

template<typename T , typename S = int>

TimeTicks v8::base::FINAL< T, S >::operator- ( const TimeDelta & delta ) const

inline

Definition at line 361 of file time.h.

                                                     {
     return TimeTicks(ticks_ - delta.InMicroseconds());
   }

◆ operator-() [5/6]

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::operator- ( const TimeDelta & other ) const

inline

Definition at line 81 of file time.h.

                                                     {
     return TimeDelta(delta_ - other.delta_);
   }

◆ operator-() [6/6]

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::operator- ( const TimeTicks other ) const

inline

Definition at line 343 of file time.h.

                                                    {
     return TimeDelta::FromMicroseconds(ticks_ - other.ticks_);
   }

◆ operator-=() [1/3]

template<typename T , typename S = int>

Time& v8::base::FINAL< T, S >::operator-= ( const TimeDelta & delta )

inline

Definition at line 243 of file time.h.

                                            {
     us_ -= delta.InMicroseconds();
     return *this;
   }

◆ operator-=() [2/3]

template<typename T , typename S = int>

TimeTicks& v8::base::FINAL< T, S >::operator-= ( const TimeDelta & delta )

inline

Definition at line 352 of file time.h.

                                                 {
     ticks_ -= delta.InMicroseconds();
     return *this;
   }

◆ operator-=() [3/3]

template<typename T , typename S = int>

TimeDelta& v8::base::FINAL< T, S >::operator-= ( const TimeDelta & other )

inline

Definition at line 89 of file time.h.

                                                 {
     delta_ -= other.delta_;
     return *this;
   }

◆ operator/() [1/2]

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::operator/ ( const TimeDelta & other ) const

inline

Definition at line 120 of file time.h.

                                                   {
     return delta_ / other.delta_;
   }

◆ operator/() [2/2]

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::operator/ ( int64_t a ) const

inline

Definition at line 109 of file time.h.

                                        {
     return TimeDelta(delta_ / a);
   }

◆ operator/=()

template<typename T , typename S = int>

TimeDelta& v8::base::FINAL< T, S >::operator/= ( int64_t a )

inline

Definition at line 116 of file time.h.

                                    {
     delta_ /= a;
     return *this;
   }

◆ operator<() [1/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator< ( const Time & other ) const

inline

Definition at line 263 of file time.h.

                                           {
     return us_ < other.us_;
   }

◆ operator<() [2/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator< ( const TimeDelta & other ) const

inline

Definition at line 131 of file time.h.

                                                {
     return delta_ < other.delta_;
   }

◆ operator<() [3/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator< ( const TimeTicks & other ) const

inline

Definition at line 372 of file time.h.

                                                {
     return ticks_ < other.ticks_;
   }

◆ operator<=() [1/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator<= ( const Time & other ) const

inline

Definition at line 266 of file time.h.

                                            {
     return us_ <= other.us_;
   }

◆ operator<=() [2/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator<= ( const TimeDelta & other ) const

inline

Definition at line 134 of file time.h.

                                                 {
     return delta_ <= other.delta_;
   }

◆ operator<=() [3/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator<= ( const TimeTicks & other ) const

inline

Definition at line 375 of file time.h.

                                                 {
     return ticks_ <= other.ticks_;
   }

◆ operator=() [1/3]

template<typename T , typename S = int>

Time& v8::base::FINAL< T, S >::operator= ( const Time & other )

inline

Definition at line 228 of file time.h.

                                      {
     us_ = other.us_;
     return *this;
   }

◆ operator=() [2/3]

template<typename T , typename S = int>

TimeDelta& v8::base::FINAL< T, S >::operator= ( const TimeDelta & other )

inline

Definition at line 72 of file time.h.

                                                {
     delta_ = other.delta_;
     return *this;
   }

◆ operator=() [3/3]

template<typename T , typename S = int>

TimeTicks& v8::base::FINAL< T, S >::operator= ( const TimeTicks other )

inline

Definition at line 337 of file time.h.

                                               {
     ticks_ = other.ticks_;
     return *this;
   }

◆ operator==() [1/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator== ( const Time & other ) const

inline

Definition at line 257 of file time.h.

                                            {
     return us_ == other.us_;
   }

◆ operator==() [2/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator== ( const TimeDelta & other ) const

inline

Definition at line 125 of file time.h.

                                                 {
     return delta_ == other.delta_;
   }

◆ operator==() [3/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator== ( const TimeTicks & other ) const

inline

Definition at line 366 of file time.h.

                                                 {
     return ticks_ == other.ticks_;
   }

◆ operator>() [1/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator> ( const Time & other ) const

inline

Definition at line 269 of file time.h.

                                           {
     return us_ > other.us_;
   }

◆ operator>() [2/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator> ( const TimeDelta & other ) const

inline

Definition at line 137 of file time.h.

                                                {
     return delta_ > other.delta_;
   }

◆ operator>() [3/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator> ( const TimeTicks & other ) const

inline

Definition at line 378 of file time.h.

                                                {
     return ticks_ > other.ticks_;
   }

◆ operator>=() [1/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator>= ( const Time & other ) const

inline

Definition at line 272 of file time.h.

                                            {
     return us_ >= other.us_;
   }

◆ operator>=() [2/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator>= ( const TimeDelta & other ) const

inline

Definition at line 140 of file time.h.

                                                 {
     return delta_ >= other.delta_;
   }

◆ operator>=() [3/3]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::operator>= ( const TimeTicks & other ) const

inline

Definition at line 381 of file time.h.

                                                 {
     return ticks_ >= other.ticks_;
   }

◆ operator^() [1/2]

template<typename T , typename S = int>

Flags v8::base::FINAL< T, S >::operator^ ( const Flags & flags ) const

inline

Definition at line 47 of file flags.h.

47 { return Flags(*this) ^= flags; }

References v8::internal::anonymous_namespace{flags.cc}::flags.

◆ operator^() [2/2]

template<typename T , typename S = int>

Flags v8::base::FINAL< T, S >::operator^ ( flag_type flag ) const

inline

Definition at line 55 of file flags.h.

55 { return operator^(Flags(flag)); }

v8::base::FINAL::operator^

Flags operator^(const Flags &flags) const

Definition: flags.h:47

References v8::internal::flag, and v8::base::FINAL< T, S >::operator^().

Referenced by v8::base::FINAL< T, S >::operator^().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator^=() [1/2]

template<typename T , typename S = int>

Flags& v8::base::FINAL< T, S >::operator^= ( const Flags & flags )

inline

Definition at line 40 of file flags.h.

                                         {
     mask_ ^= flags.mask_;
     return *this;
   }

References v8::internal::anonymous_namespace{flags.cc}::flags.

◆ operator^=() [2/2]

template<typename T , typename S = int>

Flags& v8::base::FINAL< T, S >::operator^= ( flag_type flag )

inline

Definition at line 51 of file flags.h.

51 { return operator^=(Flags(flag)); }

v8::base::FINAL::operator^=

Flags & operator^=(const Flags &flags)

Definition: flags.h:40

References v8::internal::flag, and v8::base::FINAL< T, S >::operator^=().

Referenced by v8::base::FINAL< T, S >::operator^=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator|() [1/2]

template<typename T , typename S = int>

Flags v8::base::FINAL< T, S >::operator| ( const Flags & flags ) const

inline

Definition at line 46 of file flags.h.

46 { return Flags(*this) |= flags; }

References v8::internal::anonymous_namespace{flags.cc}::flags.

◆ operator|() [2/2]

template<typename T , typename S = int>

Flags v8::base::FINAL< T, S >::operator| ( flag_type flag ) const

inline

Definition at line 54 of file flags.h.

54 { return operator|(Flags(flag)); }

v8::base::FINAL::operator|

Flags operator|(const Flags &flags) const

Definition: flags.h:46

References v8::internal::flag, and v8::base::FINAL< T, S >::operator|().

Referenced by v8::base::FINAL< T, S >::operator|().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator|=() [1/2]

template<typename T , typename S = int>

Flags& v8::base::FINAL< T, S >::operator|= ( const Flags & flags )

inline

Definition at line 36 of file flags.h.

                                         {
     mask_ |= flags.mask_;
     return *this;
   }

References v8::internal::anonymous_namespace{flags.cc}::flags.

◆ operator|=() [2/2]

template<typename T , typename S = int>

Flags& v8::base::FINAL< T, S >::operator|= ( flag_type flag )

inline

Definition at line 50 of file flags.h.

50 { return operator|=(Flags(flag)); }

v8::base::FINAL::operator|=

Flags & operator|=(const Flags &flags)

Definition: flags.h:36

References v8::internal::flag, and v8::base::FINAL< T, S >::operator|=().

Referenced by v8::base::FINAL< T, S >::operator|=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator~()

template<typename T , typename S = int>

Flags v8::base::FINAL< T, S >::operator~ ( ) const

inline

Definition at line 57 of file flags.h.

57 { return Flags(~mask_); }

◆ part()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::part ( ) const

inline

Definition at line 50 of file cpu.h.

50 { return part_; }

v8::base::FINAL::part_

int part_

Definition: cpu.h:93

◆ PercentOf()

template<typename T , typename S = int>

double v8::base::FINAL< T, S >::PercentOf ( const TimeDelta & other ) const

inline

Definition at line 100 of file time.h.

                                                  {
     return TimesOf(other) * 100.0;
   }

◆ RandomNumberGenerator() [1/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::RandomNumberGenerator ( )

◆ RandomNumberGenerator() [2/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::RandomNumberGenerator ( int64_t seed )

inlineexplicit

Definition at line 36 of file random-number-generator.h.

36 { SetSeed(seed); }

v8::base::FINAL::SetSeed

void SetSeed(int64_t seed)

◆ RecursiveMutex()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::RecursiveMutex ( )

◆ Restart()

template<typename T , typename S = int>

TimeDelta v8::base::FINAL< T, S >::Restart ( )

inline

Definition at line 55 of file elapsed-timer.h.

                       {
     DCHECK(IsStarted());
     TimeTicks ticks = Now();
     TimeDelta elapsed = ticks - start_ticks_;
     DCHECK(elapsed.InMicroseconds() >= 0);
     start_ticks_ = ticks;
     DCHECK(IsStarted());
     return elapsed;
   }

References DCHECK.

◆ Semaphore()

template<typename T , typename S = int>

v8::base::FINAL< T, S >::Semaphore ( int count )

explicit

◆ SetEntropySource()

template<typename T , typename S = int>

static void v8::base::FINAL< T, S >::SetEntropySource ( EntropySource entropy_source )

static

◆ SetSeed()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::SetSeed ( int64_t seed )

◆ Signal()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Signal ( )

◆ Start()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Start ( )

inline

Definition at line 23 of file elapsed-timer.h.

                {
     DCHECK(!IsStarted());
     start_ticks_ = Now();
 #ifdef DEBUG
     started_ = true;
 #endif
     DCHECK(IsStarted());
   }

References DCHECK.

◆ stepping()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::stepping ( ) const

inline

Definition at line 37 of file cpu.h.

37 { return stepping_; }

v8::base::FINAL::stepping_

int stepping_

Definition: cpu.h:85

◆ Stop()

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Stop ( )

inline

Definition at line 34 of file elapsed-timer.h.

               {
     DCHECK(IsStarted());
     start_ticks_ = TimeTicks();
 #ifdef DEBUG
     started_ = false;
 #endif
     DCHECK(!IsStarted());
   }

References DCHECK.

◆ Time() [1/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::Time ( )

inline

Definition at line 176 of file time.h.

176 : us_(0) {}

◆ Time() [2/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::Time ( int64_t us )

inlineexplicitprivate

Definition at line 277 of file time.h.

277 : us_(us) {}

◆ TimeDelta() [1/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::TimeDelta ( )

inline

Definition at line 35 of file time.h.

35 : delta_(0) {}

◆ TimeDelta() [2/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::TimeDelta ( int64_t delta )

inlineexplicitprivate

Definition at line 148 of file time.h.

148 : delta_(delta) {}

◆ TimesOf()

template<typename T , typename S = int>

double v8::base::FINAL< T, S >::TimesOf ( const TimeDelta & other ) const

inline

Definition at line 97 of file time.h.

                                                {
     return static_cast<double>(delta_) / static_cast<double>(other.delta_);
   }

◆ TimeTicks() [1/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::TimeTicks ( )

inline

Definition at line 300 of file time.h.

300 : ticks_(0) {}

◆ TimeTicks() [2/2]

template<typename T , typename S = int>

v8::base::FINAL< T, S >::TimeTicks ( int64_t ticks )

inlineexplicitprivate

Definition at line 388 of file time.h.

388 : ticks_(ticks) {}

◆ ToFiletime()

template<typename T , typename S = int>

struct _FILETIME v8::base::FINAL< T, S >::ToFiletime ( ) const

◆ ToInternalValue() [1/2]

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::ToInternalValue ( ) const

inline

Definition at line 207 of file time.h.

                                   {
     return us_;
   }

◆ ToInternalValue() [2/2]

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::ToInternalValue ( ) const

inline

Definition at line 333 of file time.h.

                                   {
     return ticks_;
   }

◆ ToJsTime()

template<typename T , typename S = int>

double v8::base::FINAL< T, S >::ToJsTime ( ) const

◆ ToMachTimespec()

template<typename T , typename S = int>

struct mach_timespec v8::base::FINAL< T, S >::ToMachTimespec ( ) const

◆ ToTimespec() [1/2]

template<typename T , typename S = int>

struct timespec v8::base::FINAL< T, S >::ToTimespec ( ) const

◆ ToTimespec() [2/2]

template<typename T , typename S = int>

struct timespec v8::base::FINAL< T, S >::ToTimespec ( ) const

◆ ToTimeval()

template<typename T , typename S = int>

struct timeval v8::base::FINAL< T, S >::ToTimeval ( ) const

◆ TryLock() [1/2]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::TryLock ( )

◆ TryLock() [2/2]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::TryLock ( )

◆ type()

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::type ( ) const

inline

Definition at line 42 of file cpu.h.

42 { return type_; }

v8::base::FINAL::type_

int type_

Definition: cpu.h:90

◆ UnixEpoch()

template<typename T , typename S = int>

static Time v8::base::FINAL< T, S >::UnixEpoch ( )

inlinestatic

Definition at line 196 of file time.h.

196 { return Time(0); }

◆ Unlock() [1/2]

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Unlock ( )

◆ Unlock() [2/2]

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Unlock ( )

◆ vendor()

template<typename T , typename S = int>

const char* v8::base::FINAL< T, S >::vendor ( ) const

inline

Definition at line 36 of file cpu.h.

36 { return vendor_; }

v8::base::FINAL::vendor_

char vendor_[13]

Definition: cpu.h:84

◆ Wait() [1/2]

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Wait ( )

◆ Wait() [2/2]

template<typename T , typename S = int>

void v8::base::FINAL< T, S >::Wait ( Mutex * mutex )

◆ WaitFor() [1/2]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::WaitFor ( const TimeDelta & rel_time )

◆ WaitFor() [2/2]

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::WaitFor	(	Mutex *	mutex,
		const TimeDelta &	rel_time
	)

Friends And Related Function Documentation

◆ ConditionVariable

template<typename T , typename S = int>

friend class ConditionVariable

friend

Definition at line 89 of file mutex.h.

Member Data Documentation

◆ architecture_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::architecture_

private

Definition at line 92 of file cpu.h.

◆ ARM

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::ARM = 0x41

static

Definition at line 46 of file cpu.h.

◆ ARM_CORTEX_A12

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::ARM_CORTEX_A12 = 0xc0c

static

Definition at line 55 of file cpu.h.

◆ ARM_CORTEX_A15

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::ARM_CORTEX_A15 = 0xc0f

static

Definition at line 56 of file cpu.h.

◆ ARM_CORTEX_A5

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::ARM_CORTEX_A5 = 0xc05

static

Definition at line 51 of file cpu.h.

◆ ARM_CORTEX_A7

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::ARM_CORTEX_A7 = 0xc07

static

Definition at line 52 of file cpu.h.

◆ ARM_CORTEX_A8

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::ARM_CORTEX_A8 = 0xc08

static

Definition at line 53 of file cpu.h.

◆ ARM_CORTEX_A9

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::ARM_CORTEX_A9 = 0xc09

static

Definition at line 54 of file cpu.h.

◆ delta_

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::delta_

private

Definition at line 151 of file time.h.

◆ ext_family_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::ext_family_

private

Definition at line 89 of file cpu.h.

◆ ext_model_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::ext_model_

private

Definition at line 87 of file cpu.h.

◆ family_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::family_

private

Definition at line 88 of file cpu.h.

◆ has_cmov_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_cmov_

private

Definition at line 95 of file cpu.h.

◆ has_fpu_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_fpu_

private

Definition at line 94 of file cpu.h.

◆ has_idiva_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_idiva_

private

Definition at line 104 of file cpu.h.

◆ has_mmx_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_mmx_

private

Definition at line 97 of file cpu.h.

◆ has_neon_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_neon_

private

Definition at line 105 of file cpu.h.

◆ has_sahf_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sahf_

private

Definition at line 96 of file cpu.h.

◆ has_sse2_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse2_

private

Definition at line 99 of file cpu.h.

◆ has_sse3_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse3_

private

Definition at line 100 of file cpu.h.

◆ has_sse41_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse41_

private

Definition at line 102 of file cpu.h.

◆ has_sse42_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse42_

private

Definition at line 103 of file cpu.h.

◆ has_sse_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_sse_

private

Definition at line 98 of file cpu.h.

◆ has_ssse3_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_ssse3_

private

Definition at line 101 of file cpu.h.

◆ has_thumb2_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_thumb2_

private

Definition at line 106 of file cpu.h.

◆ has_vfp3_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_vfp3_

private

Definition at line 108 of file cpu.h.

◆ has_vfp3_d32_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_vfp3_d32_

private

Definition at line 109 of file cpu.h.

◆ has_vfp_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::has_vfp_

private

Definition at line 107 of file cpu.h.

◆ implementer_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::implementer_

private

Definition at line 91 of file cpu.h.

◆ initial_seed_

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::initial_seed_

private

Definition at line 86 of file random-number-generator.h.

◆ is_fp64_mode_

template<typename T , typename S = int>

bool v8::base::FINAL< T, S >::is_fp64_mode_

private

Definition at line 110 of file cpu.h.

◆ kAddend

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kAddend = 0xb

staticprivate

Definition at line 81 of file random-number-generator.h.

◆ kMask

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMask = V8_2PART_UINT64_C(0xffff, ffffffff)

staticprivate

Definition at line 82 of file random-number-generator.h.

◆ kMicrosecondsPerDay

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMicrosecondsPerDay = kMicrosecondsPerHour * 24

static

Definition at line 169 of file time.h.

◆ kMicrosecondsPerHour

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMicrosecondsPerHour = kMicrosecondsPerMinute * 60

static

Definition at line 168 of file time.h.

◆ kMicrosecondsPerMillisecond

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMicrosecondsPerMillisecond = 1000

static

Definition at line 164 of file time.h.

◆ kMicrosecondsPerMinute

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMicrosecondsPerMinute = kMicrosecondsPerSecond * 60

static

Definition at line 167 of file time.h.

◆ kMicrosecondsPerSecond

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMicrosecondsPerSecond

static

Initial value:

= kMicrosecondsPerMillisecond *

kMillisecondsPerSecond

v8::base::FINAL::kMillisecondsPerSecond

static const int64_t kMillisecondsPerSecond

Definition: time.h:163

v8::base::FINAL::kMicrosecondsPerMillisecond

static const int64_t kMicrosecondsPerMillisecond

Definition: time.h:164

Definition at line 165 of file time.h.

◆ kMicrosecondsPerWeek

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMicrosecondsPerWeek = kMicrosecondsPerDay * 7

static

Definition at line 170 of file time.h.

◆ kMillisecondsPerSecond

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMillisecondsPerSecond = 1000

static

Definition at line 163 of file time.h.

◆ kMultiplier

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kMultiplier = V8_2PART_UINT64_C(0x5, deece66d)

staticprivate

Definition at line 80 of file random-number-generator.h.

◆ kNanosecondsPerMicrosecond

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kNanosecondsPerMicrosecond = 1000

static

Definition at line 171 of file time.h.

◆ kNanosecondsPerSecond

template<typename T , typename S = int>

const int64_t v8::base::FINAL< T, S >::kNanosecondsPerSecond

static

Initial value:

= kNanosecondsPerMicrosecond *

kMicrosecondsPerSecond

v8::base::FINAL::kNanosecondsPerMicrosecond

static const int64_t kNanosecondsPerMicrosecond

Definition: time.h:171

v8::base::FINAL::kMicrosecondsPerSecond

static const int64_t kMicrosecondsPerSecond

Definition: time.h:165

Definition at line 172 of file time.h.

◆ mask_

template<typename T , typename S = int>

mask_type v8::base::FINAL< T, S >::mask_

private

Definition at line 63 of file flags.h.

◆ model_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::model_

private

Definition at line 86 of file cpu.h.

◆ mutex_

template<typename T , typename S = int>

Mutex* v8::base::FINAL< T, S >::mutex_

private

Definition at line 208 of file mutex.h.

◆ native_handle_

template<typename T , typename S = int>

NativeHandle v8::base::FINAL< T, S >::native_handle_

private

Definition at line 94 of file condition-variable.h.

◆ NVIDIA

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::NVIDIA = 0x4e

static

Definition at line 47 of file cpu.h.

◆ part_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::part_

private

Definition at line 93 of file cpu.h.

◆ QUALCOMM

template<typename T , typename S = int>

const int v8::base::FINAL< T, S >::QUALCOMM = 0x51

static

Definition at line 48 of file cpu.h.

◆ seed_

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::seed_

private

Definition at line 87 of file random-number-generator.h.

◆ start_ticks_

template<typename T , typename S = int>

TimeTicks v8::base::FINAL< T, S >::start_ticks_

private

Definition at line 89 of file elapsed-timer.h.

◆ stepping_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::stepping_

private

Definition at line 85 of file cpu.h.

◆ ticks_

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::ticks_

private

Definition at line 391 of file time.h.

◆ type_

template<typename T , typename S = int>

int v8::base::FINAL< T, S >::type_

private

Definition at line 90 of file cpu.h.

◆ us_

template<typename T , typename S = int>

int64_t v8::base::FINAL< T, S >::us_

private

Definition at line 280 of file time.h.

◆ vendor_

template<typename T , typename S = int>

char v8::base::FINAL< T, S >::vendor_[13]

private

Definition at line 84 of file cpu.h.

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

/mnt/V8SourceCode/src/base/cpu.h
/mnt/V8SourceCode/src/base/flags.h
/mnt/V8SourceCode/src/base/platform/mutex.h
/mnt/V8SourceCode/src/base/utils/random-number-generator.h
/mnt/V8SourceCode/src/base/platform/condition-variable.h
/mnt/V8SourceCode/src/base/platform/elapsed-timer.h
/mnt/V8SourceCode/src/base/platform/semaphore.h
/mnt/V8SourceCode/src/base/platform/time.h
/mnt/V8SourceCode/src/base/sys-info.h

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

template<typename T, typename S = int> class v8::base::FINAL< T, S >

Member Typedef Documentation

◆ EntropySource

◆ flag_type

◆ mask_type

◆ NativeHandle

Constructor & Destructor Documentation

◆ ~ConditionVariable()

◆ ~Mutex()

◆ ~RecursiveMutex()

◆ ~LockGuard()

◆ ~Semaphore()

Member Function Documentation

◆ AmountOfPhysicalMemory()

◆ AmountOfVirtualMemory()

◆ architecture()

◆ AssertHeldAndUnmark()

◆ AssertUnheldAndMark()

◆ ConditionVariable()

◆ CPU()

◆ DISALLOW_COPY_AND_ASSIGN() [1/5]

◆ DISALLOW_COPY_AND_ASSIGN() [2/5]

◆ DISALLOW_COPY_AND_ASSIGN() [3/5]

◆ DISALLOW_COPY_AND_ASSIGN() [4/5]

◆ DISALLOW_COPY_AND_ASSIGN() [5/5]

◆ Elapsed()

◆ ext_family()

◆ ext_model()

◆ family()

◆ Flags() [1/3]

◆ Flags() [2/3]

◆ Flags() [3/3]

◆ FromDays()

◆ FromFiletime()

◆ FromHours()

◆ FromInternalValue() [1/2]

◆ FromInternalValue() [2/2]

◆ FromJsTime()

◆ FromMachTimespec()

◆ FromMicroseconds()

◆ FromMilliseconds()

◆ FromMinutes()

◆ FromNanoseconds()

◆ FromSeconds()

◆ FromTimespec() [1/2]

◆ FromTimespec() [2/2]

◆ FromTimeval()

◆ has_cmov()

◆ has_fpu()

◆ has_idiva()

◆ has_mmx()

◆ has_neon()

◆ has_sahf()

◆ has_sse()

◆ has_sse2()

◆ has_sse3()

◆ has_sse41()

◆ has_sse42()

◆ has_ssse3()

◆ has_thumb2()

◆ has_vfp()

◆ has_vfp3()

◆ has_vfp3_d32()

◆ HasExpired()

◆ HighResolutionNow()

◆ implementer()

◆ InDays()

◆ InHours()

◆ initial_seed()

◆ InMicroseconds()

template<typename T, typename S = int>
class v8::base::FINAL< T, S >