LCOV - code coverage report
Current view: top level - lib/Support/Unix - Threading.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 27 28 96.4 %
Date: 2018-09-23 13:06:45 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- Unix/Threading.inc - Unix Threading Implementation ----- -*- 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 provides the Unix specific implementation of Threading functions.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/ADT/SmallString.h"
      15             : #include "llvm/ADT/Twine.h"
      16             : 
      17             : #if defined(__APPLE__)
      18             : #include <mach/mach_init.h>
      19             : #include <mach/mach_port.h>
      20             : #endif
      21             : 
      22             : #include <pthread.h>
      23             : 
      24             : #if defined(__FreeBSD__) || defined(__OpenBSD__)
      25             : #include <pthread_np.h> // For pthread_getthreadid_np() / pthread_set_name_np()
      26             : #endif
      27             : 
      28             : #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
      29             : #include <errno.h>
      30             : #include <sys/sysctl.h>
      31             : #include <sys/user.h>
      32             : #include <unistd.h>
      33             : #endif
      34             : 
      35             : #if defined(__NetBSD__)
      36             : #include <lwp.h> // For _lwp_self()
      37             : #endif
      38             : 
      39             : #if defined(__linux__)
      40             : #include <sys/syscall.h> // For syscall codes
      41             : #include <unistd.h>      // For syscall()
      42             : #endif
      43             : 
      44             : namespace {
      45             :   struct ThreadInfo {
      46             :     void(*UserFn)(void *);
      47             :     void *UserData;
      48             :   };
      49             : }
      50             : 
      51        4820 : static void *ExecuteOnThread_Dispatch(void *Arg) {
      52             :   ThreadInfo *TI = reinterpret_cast<ThreadInfo*>(Arg);
      53        4820 :   TI->UserFn(TI->UserData);
      54        4820 :   return nullptr;
      55             : }
      56             : 
      57        4820 : void llvm::llvm_execute_on_thread(void(*Fn)(void*), void *UserData,
      58             :   unsigned RequestedStackSize) {
      59        4820 :   ThreadInfo Info = { Fn, UserData };
      60             :   pthread_attr_t Attr;
      61             :   pthread_t Thread;
      62             : 
      63             :   // Construct the attributes object.
      64        4820 :   if (::pthread_attr_init(&Attr) != 0)
      65           0 :     return;
      66             : 
      67             :   // Set the requested stack size, if given.
      68        4820 :   if (RequestedStackSize != 0) {
      69        3769 :     if (::pthread_attr_setstacksize(&Attr, RequestedStackSize) != 0)
      70             :       goto error;
      71             :   }
      72             : 
      73             :   // Construct and execute the thread.
      74        4820 :   if (::pthread_create(&Thread, &Attr, ExecuteOnThread_Dispatch, &Info) != 0)
      75             :     goto error;
      76             : 
      77             :   // Wait for the thread and clean up.
      78        4820 :   ::pthread_join(Thread, nullptr);
      79             : 
      80        4820 : error:
      81        4820 :   ::pthread_attr_destroy(&Attr);
      82             : }
      83             : 
      84             : 
      85        3810 : uint64_t llvm::get_threadid() {
      86             : #if defined(__APPLE__)
      87             :   // Calling "mach_thread_self()" bumps the reference count on the thread
      88             :   // port, so we need to deallocate it. mach_task_self() doesn't bump the ref
      89             :   // count.
      90             :   thread_port_t Self = mach_thread_self();
      91             :   mach_port_deallocate(mach_task_self(), Self);
      92             :   return Self;
      93             : #elif defined(__FreeBSD__)
      94             :   return uint64_t(pthread_getthreadid_np());
      95             : #elif defined(__NetBSD__)
      96             :   return uint64_t(_lwp_self());
      97             : #elif defined(__ANDROID__)
      98             :   return uint64_t(gettid());
      99             : #elif defined(__linux__)
     100        3810 :   return uint64_t(syscall(SYS_gettid));
     101             : #else
     102             :   return uint64_t(pthread_self());
     103             : #endif
     104             : }
     105             : 
     106             : 
     107             : static constexpr uint32_t get_max_thread_name_length_impl() {
     108             : #if defined(__NetBSD__)
     109             :   return PTHREAD_MAX_NAMELEN_NP;
     110             : #elif defined(__APPLE__)
     111             :   return 64;
     112             : #elif defined(__linux__)
     113             : #if HAVE_PTHREAD_SETNAME_NP
     114             :   return 16;
     115             : #else
     116             :   return 0;
     117             : #endif
     118             : #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
     119             :   return 16;
     120             : #elif defined(__OpenBSD__)
     121             :   return 32;
     122             : #else
     123             :   return 0;
     124             : #endif
     125             : }
     126             : 
     127        6294 : uint32_t llvm::get_max_thread_name_length() {
     128        6294 :   return get_max_thread_name_length_impl();
     129             : }
     130             : 
     131        3103 : void llvm::set_thread_name(const Twine &Name) {
     132             :   // Make sure the input is null terminated.
     133             :   SmallString<64> Storage;
     134        3103 :   StringRef NameStr = Name.toNullTerminatedStringRef(Storage);
     135             : 
     136             :   // Truncate from the beginning, not the end, if the specified name is too
     137             :   // long.  For one, this ensures that the resulting string is still null
     138             :   // terminated, but additionally the end of a long thread name will usually
     139             :   // be more unique than the beginning, since a common pattern is for similar
     140             :   // threads to share a common prefix.
     141             :   // Note that the name length includes the null terminator.
     142        3103 :   if (get_max_thread_name_length() > 0)
     143        6206 :     NameStr = NameStr.take_back(get_max_thread_name_length() - 1);
     144             :   (void)NameStr;
     145             : #if defined(__linux__)
     146             : #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) || defined(__ANDROID__)
     147             : #if HAVE_PTHREAD_SETNAME_NP
     148        3103 :   ::pthread_setname_np(::pthread_self(), NameStr.data());
     149             : #endif
     150             : #endif
     151             : #elif defined(__FreeBSD__) || defined(__OpenBSD__)
     152             :   ::pthread_set_name_np(::pthread_self(), NameStr.data());
     153             : #elif defined(__NetBSD__)
     154             :   ::pthread_setname_np(::pthread_self(), "%s",
     155             :     const_cast<char *>(NameStr.data()));
     156             : #elif defined(__APPLE__)
     157             :   ::pthread_setname_np(NameStr.data());
     158             : #endif
     159        3103 : }
     160             : 
     161          13 : void llvm::get_thread_name(SmallVectorImpl<char> &Name) {
     162             :   Name.clear();
     163             : 
     164             : #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
     165             :   int pid = ::getpid();
     166             :   uint64_t tid = get_threadid();
     167             : 
     168             :   struct kinfo_proc *kp = nullptr, *nkp;
     169             :   size_t len = 0;
     170             :   int error;
     171             :   int ctl[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
     172             :     (int)pid };
     173             : 
     174             :   while (1) {
     175             :     error = sysctl(ctl, 4, kp, &len, nullptr, 0);
     176             :     if (kp == nullptr || (error != 0 && errno == ENOMEM)) {
     177             :       // Add extra space in case threads are added before next call.
     178             :       len += sizeof(*kp) + len / 10;
     179             :       nkp = (struct kinfo_proc *)::realloc(kp, len);
     180             :       if (nkp == nullptr) {
     181             :         free(kp);
     182             :         return;
     183             :       }
     184             :       kp = nkp;
     185             :       continue;
     186             :     }
     187             :     if (error != 0)
     188             :       len = 0;
     189             :     break;
     190             :   }
     191             : 
     192             :   for (size_t i = 0; i < len / sizeof(*kp); i++) {
     193             :     if (kp[i].ki_tid == (lwpid_t)tid) {
     194             :       Name.append(kp[i].ki_tdname, kp[i].ki_tdname + strlen(kp[i].ki_tdname));
     195             :       break;
     196             :     }
     197             :   }
     198             :   free(kp);
     199             :   return;
     200             : #elif defined(__NetBSD__)
     201             :   constexpr uint32_t len = get_max_thread_name_length_impl();
     202             :   char buf[len];
     203             :   ::pthread_getname_np(::pthread_self(), buf, len);
     204             : 
     205             :   Name.append(buf, buf + strlen(buf));
     206             : #elif defined(__linux__)
     207             : #if HAVE_PTHREAD_GETNAME_NP
     208             :   constexpr uint32_t len = get_max_thread_name_length_impl();
     209          13 :   char Buffer[len] = {'\0'};  // FIXME: working around MSan false positive.
     210          13 :   if (0 == ::pthread_getname_np(::pthread_self(), Buffer, len))
     211          13 :     Name.append(Buffer, Buffer + strlen(Buffer));
     212             : #endif
     213             : #endif
     214          13 : }

Generated by: LCOV version 1.13