1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // XFAIL: libcpp-no-exceptions 11 // UNSUPPORTED: libcpp-has-no-threads 12 13 // <thread> 14 15 // class thread 16 17 // template <class F, class ...Args> thread(F&& f, Args&&... args); 18 19 // UNSUPPORTED: sanitizer-new-delete 20 21 #include <thread> 22 #include <new> 23 #include <atomic> 24 #include <cstdlib> 25 #include <cassert> 26 27 #include "test_macros.h" 28 29 std::atomic<unsigned> throw_one(0xFFFF); 30 std::atomic<unsigned> outstanding_new(0); 31 32 33 void* operator new(std::size_t s) throw(std::bad_alloc) 34 { 35 if (throw_one == 0) 36 throw std::bad_alloc(); 37 --throw_one; 38 ++outstanding_new; 39 return std::malloc(s); 40 } 41 42 void operator delete(void* p) throw() 43 { 44 --outstanding_new; 45 std::free(p); 46 } 47 48 bool f_run = false; 49 50 void f() 51 { 52 f_run = true; 53 } 54 55 class G 56 { 57 int alive_; 58 public: 59 static int n_alive; 60 static bool op_run; 61 62 G() : alive_(1) {++n_alive;} 63 G(const G& g) : alive_(g.alive_) {++n_alive;} 64 ~G() {alive_ = 0; --n_alive;} 65 66 void operator()() 67 { 68 assert(alive_ == 1); 69 assert(n_alive >= 1); 70 op_run = true; 71 } 72 73 void operator()(int i, double j) 74 { 75 assert(alive_ == 1); 76 assert(n_alive >= 1); 77 assert(i == 5); 78 assert(j == 5.5); 79 op_run = true; 80 } 81 }; 82 83 int G::n_alive = 0; 84 bool G::op_run = false; 85 86 #if TEST_STD_VER >= 11 87 88 class MoveOnly 89 { 90 MoveOnly(const MoveOnly&); 91 public: 92 MoveOnly() {} 93 MoveOnly(MoveOnly&&) {} 94 95 void operator()(MoveOnly&&) 96 { 97 } 98 }; 99 100 #endif 101 102 // Test throwing std::bad_alloc 103 //----------------------------- 104 // Concerns: 105 // A Each allocation performed during thread construction should be performed 106 // in the parent thread so that std::terminate is not called if 107 // std::bad_alloc is thrown by new. 108 // B std::threads constructor should properly handle exceptions and not leak 109 // memory. 110 // Plan: 111 // 1 Create a thread and count the number of allocations, 'N', it performs. 112 // 2 For each allocation performed run a test where that allocation throws. 113 // 2.1 check that the exception can be caught in the parent thread. 114 // 2.2 Check that the functor has not been called. 115 // 2.3 Check that no memory allocated by the creation of the thread is leaked. 116 // 3 Finally check that a thread runs successfully if we throw after 'N+1' 117 // allocations. 118 void test_throwing_new_during_thread_creation() { 119 throw_one = 0xFFF; 120 { 121 std::thread t(f); 122 t.join(); 123 } 124 const int numAllocs = 0xFFF - throw_one; 125 // i <= numAllocs means the last iteration is expected not to throw. 126 for (int i=0; i <= numAllocs; ++i) { 127 throw_one = i; 128 f_run = false; 129 unsigned old_outstanding = outstanding_new; 130 try { 131 std::thread t(f); 132 assert(i == numAllocs); // Only final iteration will not throw. 133 t.join(); 134 assert(f_run); 135 } catch (std::bad_alloc const&) { 136 assert(i < numAllocs); 137 assert(!f_run); // (2.2) 138 } 139 assert(old_outstanding == outstanding_new); // (2.3) 140 } 141 f_run = false; 142 throw_one = 0xFFF; 143 } 144 145 int main() 146 { 147 test_throwing_new_during_thread_creation(); 148 { 149 std::thread t(f); 150 t.join(); 151 assert(f_run == true); 152 } 153 154 { 155 assert(G::n_alive == 0); 156 assert(!G::op_run); 157 std::thread t((G())); 158 t.join(); 159 assert(G::n_alive == 0); 160 assert(G::op_run); 161 } 162 G::op_run = false; 163 { 164 try 165 { 166 throw_one = 0; 167 assert(G::n_alive == 0); 168 assert(!G::op_run); 169 std::thread t((G())); 170 assert(false); 171 } 172 catch (...) 173 { 174 throw_one = 0xFFFF; 175 assert(G::n_alive == 0); 176 assert(!G::op_run); 177 } 178 } 179 #if TEST_STD_VER >= 11 180 { 181 assert(G::n_alive == 0); 182 assert(!G::op_run); 183 std::thread t(G(), 5, 5.5); 184 t.join(); 185 assert(G::n_alive == 0); 186 assert(G::op_run); 187 } 188 { 189 std::thread t = std::thread(MoveOnly(), MoveOnly()); 190 t.join(); 191 } 192 #endif 193 } 194
