Coverage Report

Created: 2020-11-24 06:42

/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/src/thread.cpp
Line
Count
Source (jump to first uncovered line)
1
//===------------------------- thread.cpp----------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#include "__config"
10
#ifndef _LIBCPP_HAS_NO_THREADS
11
12
#include "thread"
13
#include "exception"
14
#include "vector"
15
#include "future"
16
#include "limits"
17
18
#if __has_include(<sys/types.h>)
19
# include <sys/types.h>
20
#endif
21
22
#if __has_include(<sys/param.h>)
23
# include <sys/param.h>
24
#endif
25
26
#if __has_include(<sys/sysctl.h>)
27
# include <sys/sysctl.h>
28
#endif
29
30
#if __has_include(<unistd.h>)
31
# include <unistd.h>
32
#endif
33
34
#if defined(__NetBSD__)
35
#pragma weak pthread_create // Do not create libpthread dependency
36
#endif
37
38
#if defined(_LIBCPP_WIN32API)
39
#include <windows.h>
40
#endif
41
42
#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
43
#pragma comment(lib, "pthread")
44
#endif
45
46
_LIBCPP_BEGIN_NAMESPACE_STD
47
48
thread::~thread()
49
59
{
50
59
    if (!__libcpp_thread_isnull(&__t_))
51
0
        terminate();
52
59
}
53
54
void
55
thread::join()
56
38
{
57
38
    int ec = EINVAL;
58
38
    if (!__libcpp_thread_isnull(&__t_))
59
38
    {
60
38
        ec = __libcpp_thread_join(&__t_);
61
38
        if (ec == 0)
62
38
            __t_ = _LIBCPP_NULL_THREAD;
63
38
    }
64
65
38
    if (ec)
66
0
        __throw_system_error(ec, "thread::join failed");
67
38
}
68
69
void
70
thread::detach()
71
8
{
72
8
    int ec = EINVAL;
73
8
    if (!__libcpp_thread_isnull(&__t_))
74
8
    {
75
8
        ec = __libcpp_thread_detach(&__t_);
76
8
        if (ec == 0)
77
8
            __t_ = _LIBCPP_NULL_THREAD;
78
8
    }
79
80
8
    if (ec)
81
0
        __throw_system_error(ec, "thread::detach failed");
82
8
}
83
84
unsigned
85
thread::hardware_concurrency() _NOEXCEPT
86
2
{
87
2
#if defined(CTL_HW) && defined(HW_NCPU)
88
2
    unsigned n;
89
2
    int mib[2] = {CTL_HW, HW_NCPU};
90
2
    std::size_t s = sizeof(n);
91
2
    sysctl(mib, 2, &n, &s, 0, 0);
92
2
    return n;
93
#elif defined(_SC_NPROCESSORS_ONLN)
94
    long result = sysconf(_SC_NPROCESSORS_ONLN);
95
    // sysconf returns -1 if the name is invalid, the option does not exist or
96
    // does not have a definite limit.
97
    // if sysconf returns some other negative number, we have no idea
98
    // what is going on. Default to something safe.
99
    if (result < 0)
100
        return 0;
101
    return static_cast<unsigned>(result);
102
#elif defined(_LIBCPP_WIN32API)
103
    SYSTEM_INFO info;
104
    GetSystemInfo(&info);
105
    return info.dwNumberOfProcessors;
106
#else  // defined(CTL_HW) && defined(HW_NCPU)
107
    // TODO: grovel through /proc or check cpuid on x86 and similar
108
    // instructions on other architectures.
109
#   if defined(_LIBCPP_WARNING)
110
        _LIBCPP_WARNING("hardware_concurrency not yet implemented")
111
#   else
112
#       warning hardware_concurrency not yet implemented
113
#   endif
114
    return 0;  // Means not computable [thread.thread.static]
115
#endif  // defined(CTL_HW) && defined(HW_NCPU)
116
2
}
117
118
namespace this_thread
119
{
120
121
void
122
sleep_for(const chrono::nanoseconds& ns)
123
6
{
124
6
    if (ns > chrono::nanoseconds::zero())
125
6
    {
126
6
        __libcpp_thread_sleep_for(ns);
127
6
    }
128
6
}
129
130
}  // this_thread
131
132
__thread_specific_ptr<__thread_struct>&
133
__thread_local_data()
134
56
{
135
56
    static __thread_specific_ptr<__thread_struct> __p;
136
56
    return __p;
137
56
}
138
139
// __thread_struct_imp
140
141
template <class T>
142
class _LIBCPP_HIDDEN __hidden_allocator
143
{
144
public:
145
    typedef T  value_type;
146
147
    T* allocate(size_t __n)
148
0
        {return static_cast<T*>(::operator new(__n * sizeof(T)));}
Unexecuted instantiation: std::__1::__hidden_allocator<std::__1::pair<std::__1::condition_variable*, std::__1::mutex*> >::allocate(unsigned long)
Unexecuted instantiation: std::__1::__hidden_allocator<std::__1::__assoc_sub_state*>::allocate(unsigned long)
149
0
    void deallocate(T* __p, size_t) {::operator delete(static_cast<void*>(__p));}
Unexecuted instantiation: std::__1::__hidden_allocator<std::__1::__assoc_sub_state*>::deallocate(std::__1::__assoc_sub_state**, unsigned long)
Unexecuted instantiation: std::__1::__hidden_allocator<std::__1::pair<std::__1::condition_variable*, std::__1::mutex*> >::deallocate(std::__1::pair<std::__1::condition_variable*, std::__1::mutex*>*, unsigned long)
150
151
0
    size_t max_size() const {return size_t(~0) / sizeof(T);}
Unexecuted instantiation: std::__1::__hidden_allocator<std::__1::pair<std::__1::condition_variable*, std::__1::mutex*> >::max_size() const
Unexecuted instantiation: std::__1::__hidden_allocator<std::__1::__assoc_sub_state*>::max_size() const
152
};
153
154
class _LIBCPP_HIDDEN __thread_struct_imp
155
{
156
    typedef vector<__assoc_sub_state*,
157
                          __hidden_allocator<__assoc_sub_state*> > _AsyncStates;
158
    typedef vector<pair<condition_variable*, mutex*>,
159
               __hidden_allocator<pair<condition_variable*, mutex*> > > _Notify;
160
161
    _AsyncStates async_states_;
162
    _Notify notify_;
163
164
    __thread_struct_imp(const __thread_struct_imp&);
165
    __thread_struct_imp& operator=(const __thread_struct_imp&);
166
public:
167
56
    __thread_struct_imp() {}
168
    ~__thread_struct_imp();
169
170
    void notify_all_at_thread_exit(condition_variable* cv, mutex* m);
171
    void __make_ready_at_thread_exit(__assoc_sub_state* __s);
172
};
173
174
__thread_struct_imp::~__thread_struct_imp()
175
56
{
176
56
    for (_Notify::iterator i = notify_.begin(), e = notify_.end();
177
56
            i != e; 
++i0
)
178
0
    {
179
0
        i->second->unlock();
180
0
        i->first->notify_all();
181
0
    }
182
56
    for (_AsyncStates::iterator i = async_states_.begin(), e = async_states_.end();
183
56
            i != e; 
++i0
)
184
0
    {
185
0
        (*i)->__make_ready();
186
0
        (*i)->__release_shared();
187
0
    }
188
56
}
189
190
void
191
__thread_struct_imp::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
192
0
{
193
0
    notify_.push_back(pair<condition_variable*, mutex*>(cv, m));
194
0
}
195
196
void
197
__thread_struct_imp::__make_ready_at_thread_exit(__assoc_sub_state* __s)
198
0
{
199
0
    async_states_.push_back(__s);
200
0
    __s->__add_shared();
201
0
}
202
203
// __thread_struct
204
205
__thread_struct::__thread_struct()
206
    : __p_(new __thread_struct_imp)
207
56
{
208
56
}
209
210
__thread_struct::~__thread_struct()
211
56
{
212
56
    delete __p_;
213
56
}
214
215
void
216
__thread_struct::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
217
0
{
218
0
    __p_->notify_all_at_thread_exit(cv, m);
219
0
}
220
221
void
222
__thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s)
223
0
{
224
0
    __p_->__make_ready_at_thread_exit(__s);
225
0
}
226
227
_LIBCPP_END_NAMESPACE_STD
228
229
#endif // !_LIBCPP_HAS_NO_THREADS