LLVM  6.0.0svn
Threading.inc
Go to the documentation of this file.
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__)
25 #include <pthread_np.h> // For pthread_getthreadid_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 static void *ExecuteOnThread_Dispatch(void *Arg) {
52  ThreadInfo *TI = reinterpret_cast<ThreadInfo*>(Arg);
53  TI->UserFn(TI->UserData);
54  return nullptr;
55 }
56 
57 void llvm::llvm_execute_on_thread(void(*Fn)(void*), void *UserData,
58  unsigned RequestedStackSize) {
59  ThreadInfo Info = { Fn, UserData };
60  pthread_attr_t Attr;
61  pthread_t Thread;
62 
63  // Construct the attributes object.
64  if (::pthread_attr_init(&Attr) != 0)
65  return;
66 
67  // Set the requested stack size, if given.
68  if (RequestedStackSize != 0) {
69  if (::pthread_attr_setstacksize(&Attr, RequestedStackSize) != 0)
70  goto error;
71  }
72 
73  // Construct and execute the thread.
74  if (::pthread_create(&Thread, &Attr, ExecuteOnThread_Dispatch, &Info) != 0)
75  goto error;
76 
77  // Wait for the thread and clean up.
78  ::pthread_join(Thread, nullptr);
79 
80 error:
81  ::pthread_attr_destroy(&Attr);
82 }
83 
84 
85 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  return uint64_t(syscall(SYS_gettid));
101 #elif defined(LLVM_ON_WIN32)
102  return uint64_t(::GetCurrentThreadId());
103 #else
104  return uint64_t(pthread_self());
105 #endif
106 }
107 
108 
109 static constexpr uint32_t get_max_thread_name_length_impl() {
110 #if defined(__NetBSD__)
111  return PTHREAD_MAX_NAMELEN_NP;
112 #elif defined(__APPLE__)
113  return 64;
114 #elif defined(__linux__)
115 #if HAVE_PTHREAD_SETNAME_NP
116  return 16;
117 #else
118  return 0;
119 #endif
120 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
121  return 16;
122 #else
123  return 0;
124 #endif
125 }
126 
128  return get_max_thread_name_length_impl();
129 }
130 
131 void llvm::set_thread_name(const Twine &Name) {
132  // Make sure the input is null terminated.
133  SmallString<64> Storage;
134  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  if (get_max_thread_name_length() > 0)
142  NameStr = NameStr.take_back(get_max_thread_name_length());
143  (void)NameStr;
144 #if defined(__linux__)
145 #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) || defined(__ANDROID__)
146 #if HAVE_PTHREAD_SETNAME_NP
147  ::pthread_setname_np(::pthread_self(), NameStr.data());
148 #endif
149 #endif
150 #elif defined(__FreeBSD__)
151  ::pthread_set_name_np(::pthread_self(), NameStr.data());
152 #elif defined(__NetBSD__)
153  ::pthread_setname_np(::pthread_self(), "%s",
154  const_cast<char *>(NameStr.data()));
155 #elif defined(__APPLE__)
156  ::pthread_setname_np(NameStr.data());
157 #endif
158 }
159 
160 void llvm::get_thread_name(SmallVectorImpl<char> &Name) {
161  Name.clear();
162 
163 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
164  int pid = ::getpid();
165  uint64_t tid = get_threadid();
166 
167  struct kinfo_proc *kp = nullptr, *nkp;
168  size_t len = 0;
169  int error;
170  int ctl[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
171  (int)pid };
172 
173  while (1) {
174  error = sysctl(ctl, 4, kp, &len, nullptr, 0);
175  if (kp == nullptr || (error != 0 && errno == ENOMEM)) {
176  // Add extra space in case threads are added before next call.
177  len += sizeof(*kp) + len / 10;
178  nkp = (struct kinfo_proc *)realloc(kp, len);
179  if (nkp == nullptr) {
180  free(kp);
181  return;
182  }
183  kp = nkp;
184  continue;
185  }
186  if (error != 0)
187  len = 0;
188  break;
189  }
190 
191  for (size_t i = 0; i < len / sizeof(*kp); i++) {
192  if (kp[i].ki_tid == (lwpid_t)tid) {
193  Name.append(kp[i].ki_tdname, kp[i].ki_tdname + strlen(kp[i].ki_tdname));
194  break;
195  }
196  }
197  free(kp);
198  return;
199 #elif defined(__NetBSD__)
200  constexpr uint32_t len = get_max_thread_name_length_impl();
201  char buf[len];
202  ::pthread_getname_np(::pthread_self(), buf, len);
203 
204  Name.append(buf, buf + strlen(buf));
205 #elif defined(__linux__)
206 #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) || defined(__ANDROID__)
207 #if HAVE_PTHREAD_GETNAME_NP
208  constexpr uint32_t len = get_max_thread_name_length_impl();
209  char Buffer[len];
210  if (0 == ::pthread_getname_np(::pthread_self(), Buffer, len))
211  Name.append(Buffer, Buffer + strlen(Buffer));
212 #endif
213 #endif
214 #endif
215 }
void set_thread_name(const Twine &Name)
Set the name of the current thread.
#define error(X)
uint32_t get_max_thread_name_length()
Get the maximum length of a thread name on this platform.
void get_thread_name(SmallVectorImpl< char > &Name)
Get the name of the current thread.
uint64_t get_threadid()
Return the current thread id, as used in various OS system calls.
void llvm_execute_on_thread(void(*UserFn)(void *), void *UserData, unsigned RequestedStackSize=0)
llvm_execute_on_thread - Execute the given UserFn on a separate thread, passing it the provided UserD...
amdgpu Simplify well known AMD library false Value Value * Arg