LCOV - code coverage report
Current view: top level - lib/Support - Threading.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 9 12 75.0 %
Date: 2018-06-17 00:07:59 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/Support/Threading.cpp- Control multithreading mode --*- C++ -*-==//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file defines helper functions for running LLVM in a multi-threaded
      11             : // environment.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "llvm/Support/Threading.h"
      16             : #include "llvm/Config/config.h"
      17             : #include "llvm/Support/Host.h"
      18             : 
      19             : #include <cassert>
      20             : #include <errno.h>
      21             : #include <stdlib.h>
      22             : #include <string.h>
      23             : 
      24             : using namespace llvm;
      25             : 
      26             : //===----------------------------------------------------------------------===//
      27             : //=== WARNING: Implementation here must contain only TRULY operating system
      28             : //===          independent code.
      29             : //===----------------------------------------------------------------------===//
      30             : 
      31    64719531 : bool llvm::llvm_is_multithreaded() {
      32             : #if LLVM_ENABLE_THREADS != 0
      33    64719531 :   return true;
      34             : #else
      35             :   return false;
      36             : #endif
      37             : }
      38             : 
      39             : #if LLVM_ENABLE_THREADS == 0 ||                                                \
      40             :     (!defined(_WIN32) && !defined(HAVE_PTHREAD_H))
      41             : // Support for non-Win32, non-pthread implementation.
      42             : void llvm::llvm_execute_on_thread(void (*Fn)(void *), void *UserData,
      43             :                                   unsigned RequestedStackSize) {
      44             :   (void)RequestedStackSize;
      45             :   Fn(UserData);
      46             : }
      47             : 
      48             : unsigned llvm::heavyweight_hardware_concurrency() { return 1; }
      49             : 
      50             : unsigned llvm::hardware_concurrency() { return 1; }
      51             : 
      52             : uint64_t llvm::get_threadid() { return 0; }
      53             : 
      54             : uint32_t llvm::get_max_thread_name_length() { return 0; }
      55             : 
      56             : void llvm::set_thread_name(const Twine &Name) {}
      57             : 
      58             : void llvm::get_thread_name(SmallVectorImpl<char> &Name) { Name.clear(); }
      59             : 
      60             : #else
      61             : 
      62             : #include <thread>
      63      101679 : unsigned llvm::heavyweight_hardware_concurrency() {
      64             :   // Since we can't get here unless LLVM_ENABLE_THREADS == 1, it is safe to use
      65             :   // `std::thread` directly instead of `llvm::thread` (and indeed, doing so
      66             :   // allows us to not define `thread` in the llvm namespace, which conflicts
      67             :   // with some platforms such as FreeBSD whose headers also define a struct
      68             :   // called `thread` in the global namespace which can cause ambiguity due to
      69             :   // ADL.
      70      101679 :   int NumPhysical = sys::getHostNumPhysicalCores();
      71      101679 :   if (NumPhysical == -1)
      72           0 :     return std::thread::hardware_concurrency();
      73      101679 :   return NumPhysical;
      74             : }
      75             : 
      76        4702 : unsigned llvm::hardware_concurrency() {
      77             : #if defined(HAVE_SCHED_GETAFFINITY) && defined(HAVE_CPU_COUNT)
      78             :   cpu_set_t Set;
      79        4702 :   if (sched_getaffinity(0, sizeof(Set), &Set))
      80           0 :     return CPU_COUNT(&Set);
      81             : #endif
      82             :   // Guard against std::thread::hardware_concurrency() returning 0.
      83        4702 :   if (unsigned Val = std::thread::hardware_concurrency())
      84             :     return Val;
      85           0 :   return 1;
      86             : }
      87             : 
      88             : // Include the platform-specific parts of this class.
      89             : #ifdef LLVM_ON_UNIX
      90             : #include "Unix/Threading.inc"
      91             : #endif
      92             : #ifdef _WIN32
      93             : #include "Windows/Threading.inc"
      94             : #endif
      95             : 
      96             : #endif

Generated by: LCOV version 1.13