LCOV - code coverage report
Current view: top level - src/base/platform - mutex.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 42 45 93.3 %
Date: 2017-04-26 Functions: 9 10 90.0 %

          Line data    Source code
       1             : // Copyright 2013 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/base/platform/mutex.h"
       6             : 
       7             : #include <errno.h>
       8             : 
       9             : namespace v8 {
      10             : namespace base {
      11             : 
      12             : #if V8_OS_POSIX
      13             : 
      14             : static V8_INLINE void InitializeNativeHandle(pthread_mutex_t* mutex) {
      15             :   int result;
      16             : #if defined(DEBUG)
      17             :   // Use an error checking mutex in debug mode.
      18             :   pthread_mutexattr_t attr;
      19             :   result = pthread_mutexattr_init(&attr);
      20             :   DCHECK_EQ(0, result);
      21             :   result = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
      22             :   DCHECK_EQ(0, result);
      23             :   result = pthread_mutex_init(mutex, &attr);
      24             :   DCHECK_EQ(0, result);
      25             :   result = pthread_mutexattr_destroy(&attr);
      26             : #else
      27             :   // Use a fast mutex (default attributes).
      28     3205347 :   result = pthread_mutex_init(mutex, NULL);
      29             : #endif  // defined(DEBUG)
      30             :   DCHECK_EQ(0, result);
      31     3205346 :   USE(result);
      32             : }
      33             : 
      34             : 
      35             : static V8_INLINE void InitializeRecursiveNativeHandle(pthread_mutex_t* mutex) {
      36             :   pthread_mutexattr_t attr;
      37      961141 :   int result = pthread_mutexattr_init(&attr);
      38             :   DCHECK_EQ(0, result);
      39      961141 :   result = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
      40             :   DCHECK_EQ(0, result);
      41      961141 :   result = pthread_mutex_init(mutex, &attr);
      42             :   DCHECK_EQ(0, result);
      43      961141 :   result = pthread_mutexattr_destroy(&attr);
      44             :   DCHECK_EQ(0, result);
      45      961141 :   USE(result);
      46             : }
      47             : 
      48             : 
      49             : static V8_INLINE void DestroyNativeHandle(pthread_mutex_t* mutex) {
      50     3814990 :   int result = pthread_mutex_destroy(mutex);
      51             :   DCHECK_EQ(0, result);
      52     3814970 :   USE(result);
      53             : }
      54             : 
      55             : 
      56             : static V8_INLINE void LockNativeHandle(pthread_mutex_t* mutex) {
      57   198327517 :   int result = pthread_mutex_lock(mutex);
      58             :   DCHECK_EQ(0, result);
      59   198362999 :   USE(result);
      60             : }
      61             : 
      62             : 
      63             : static V8_INLINE void UnlockNativeHandle(pthread_mutex_t* mutex) {
      64   198356375 :   int result = pthread_mutex_unlock(mutex);
      65             :   DCHECK_EQ(0, result);
      66   198363545 :   USE(result);
      67             : }
      68             : 
      69             : 
      70             : static V8_INLINE bool TryLockNativeHandle(pthread_mutex_t* mutex) {
      71           4 :   int result = pthread_mutex_trylock(mutex);
      72           4 :   if (result == EBUSY) {
      73             :     return false;
      74             :   }
      75             :   DCHECK_EQ(0, result);
      76             :   return true;
      77             : }
      78             : 
      79             : #elif V8_OS_WIN
      80             : 
      81             : static V8_INLINE void InitializeNativeHandle(PCRITICAL_SECTION cs) {
      82             :   InitializeCriticalSection(cs);
      83             : }
      84             : 
      85             : 
      86             : static V8_INLINE void InitializeRecursiveNativeHandle(PCRITICAL_SECTION cs) {
      87             :   InitializeCriticalSection(cs);
      88             : }
      89             : 
      90             : 
      91             : static V8_INLINE void DestroyNativeHandle(PCRITICAL_SECTION cs) {
      92             :   DeleteCriticalSection(cs);
      93             : }
      94             : 
      95             : 
      96             : static V8_INLINE void LockNativeHandle(PCRITICAL_SECTION cs) {
      97             :   EnterCriticalSection(cs);
      98             : }
      99             : 
     100             : 
     101             : static V8_INLINE void UnlockNativeHandle(PCRITICAL_SECTION cs) {
     102             :   LeaveCriticalSection(cs);
     103             : }
     104             : 
     105             : 
     106             : static V8_INLINE bool TryLockNativeHandle(PCRITICAL_SECTION cs) {
     107             :   return TryEnterCriticalSection(cs) != FALSE;
     108             : }
     109             : 
     110             : #endif  // V8_OS_POSIX
     111             : 
     112             : 
     113     3205347 : Mutex::Mutex() {
     114     3205347 :   InitializeNativeHandle(&native_handle_);
     115             : #ifdef DEBUG
     116             :   level_ = 0;
     117             : #endif
     118     3205346 : }
     119             : 
     120             : 
     121     2877415 : Mutex::~Mutex() {
     122     2877415 :   DestroyNativeHandle(&native_handle_);
     123             :   DCHECK_EQ(0, level_);
     124     2877417 : }
     125             : 
     126             : 
     127   183281878 : void Mutex::Lock() {
     128   183281878 :   LockNativeHandle(&native_handle_);
     129             :   AssertUnheldAndMark();
     130   183315595 : }
     131             : 
     132             : 
     133   183310723 : void Mutex::Unlock() {
     134             :   AssertHeldAndUnmark();
     135   183310723 :   UnlockNativeHandle(&native_handle_);
     136   183312372 : }
     137             : 
     138             : 
     139           0 : bool Mutex::TryLock() {
     140           0 :   if (!TryLockNativeHandle(&native_handle_)) {
     141             :     return false;
     142             :   }
     143             :   AssertUnheldAndMark();
     144           0 :   return true;
     145             : }
     146             : 
     147             : 
     148      961141 : RecursiveMutex::RecursiveMutex() {
     149      961141 :   InitializeRecursiveNativeHandle(&native_handle_);
     150             : #ifdef DEBUG
     151             :   level_ = 0;
     152             : #endif
     153      961141 : }
     154             : 
     155             : 
     156      937575 : RecursiveMutex::~RecursiveMutex() {
     157      937575 :   DestroyNativeHandle(&native_handle_);
     158             :   DCHECK_EQ(0, level_);
     159      937553 : }
     160             : 
     161             : 
     162    15045639 : void RecursiveMutex::Lock() {
     163    15045639 :   LockNativeHandle(&native_handle_);
     164             : #ifdef DEBUG
     165             :   DCHECK_LE(0, level_);
     166             :   level_++;
     167             : #endif
     168    15045710 : }
     169             : 
     170             : 
     171    15045652 : void RecursiveMutex::Unlock() {
     172             : #ifdef DEBUG
     173             :   DCHECK_LT(0, level_);
     174             :   level_--;
     175             : #endif
     176    15045652 :   UnlockNativeHandle(&native_handle_);
     177    15045708 : }
     178             : 
     179             : 
     180           4 : bool RecursiveMutex::TryLock() {
     181           8 :   if (!TryLockNativeHandle(&native_handle_)) {
     182             :     return false;
     183             :   }
     184             : #ifdef DEBUG
     185             :   DCHECK_LE(0, level_);
     186             :   level_++;
     187             : #endif
     188           4 :   return true;
     189             : }
     190             : 
     191             : }  // namespace base
     192             : }  // namespace v8

Generated by: LCOV version 1.10