CoCalc -- test_ThreadsListHandle.cpp

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/test/hotspot/gtest/runtime/test_ThreadsListHandle.cpp
⁴¹¹⁴⁴ views
1
/*
2
 * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 */
23

24
#include "precompiled.hpp"
25
#include "runtime/thread.inline.hpp"
26
#include "runtime/threadSMR.hpp"
27
#include "unittest.hpp"
28

29
class ThreadsListHandleTest : public ::testing::Test {
30
  public:
31
    // Accessors for the Threads class:
32
    //
33
    // Return the protected Thread::_threads_hazard_ptr field:
34
    static ThreadsList* get_Thread_threads_hazard_ptr(Thread* thr) {
35
      return thr->get_threads_hazard_ptr();
36
    }
37
    // Return the protected Thread::_threads_list_ptr field:
38
    static SafeThreadsListPtr* get_Thread_threads_list_ptr(Thread* thr) {
39
      return thr->_threads_list_ptr;
40
    }
41
    // Return the protected Thread::_nested_threads_hazard_ptr_cnt field:
42
    static uint get_Thread_nested_threads_hazard_ptr_cnt(Thread* thr) {
43
      return thr->nested_threads_hazard_ptr_cnt();
44
    }
45

46
    // Accessors for the ThreadsListHandle class:
47
    //
48
    // Return the private ThreadsListHandle::_list_ptr field:
49
    static SafeThreadsListPtr* get_TLH_list_ptr(ThreadsListHandle* tlh_p) {
50
      return &tlh_p->_list_ptr;
51
    }
52

53
    // Accessors for the ThreadsList class:
54
    //
55
    // Return the private ThreadsList::_nested_handle_cnt field:
56
    static intx get_TL_nested_handle_cnt(ThreadsList* tl_p) {
57
      return tl_p->_nested_handle_cnt;
58
    }
59

60
    // Accessors for the SafeThreadsListPtr class:
61
    //
62
    // Return the private SafeThreadsListPtr::_thread field:
63
    static Thread* get_STLP_thread(SafeThreadsListPtr* stlp_p) {
64
      return stlp_p->_thread;
65
    }
66
    // Return the private SafeThreadsListPtr::_has_ref_count field:
67
    static bool get_STLP_has_ref_count(SafeThreadsListPtr* stlp_p) {
68
      return stlp_p->_has_ref_count;
69
    }
70
    // Return the private SafeThreadsListPtr::_needs_release field:
71
    static bool get_STLP_needs_release(SafeThreadsListPtr* stlp_p) {
72
      return stlp_p->_needs_release;
73
    }
74
};
75

76
TEST_VM(ThreadsListHandle, sanity) {
77
  bool saved_flag_val = EnableThreadSMRStatistics;
78
  EnableThreadSMRStatistics = true;  // enable Thread::_nested_threads_hazard_ptr_cnt
79

80
  Thread* thr = Thread::current();
81

82
  // Test case: no ThreadsListHandle
83
  //
84

85
  // Verify the current thread refers to no ThreadsListHandle:
86
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
87
      << "thr->_threads_hazard_ptr must be NULL";
88
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), (SafeThreadsListPtr*) NULL)
89
      << "thr->_threads_list_ptr must be NULL";
90
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
91
      << "thr->_nested_threads_hazard_ptr_cnt must be 0";
92

93
  // Test case: single ThreadsListHandle, no recursion
94
  //
95
  {
96
    ThreadsListHandle tlh1;
97
    SafeThreadsListPtr* list_ptr1 = ThreadsListHandleTest::get_TLH_list_ptr(&tlh1);
98

99
    // Verify the current thread refers to tlh1:
100
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh1.list())
101
        << "thr->_threads_hazard_ptr must match tlh1.list()";
102
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
103
        << "thr->_threads_list_ptr must match list_ptr1";
104
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
105
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
106

107
    // Verify tlh1 has the right field values:
108
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
109
        << "list_ptr1->previous() must be NULL";
110
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
111
        << "list_ptr1->_thread must match current thread";
112
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
113
        << "list_ptr1->list() must match tlh1.list()";
114
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), false)
115
        << "list_ptr1->_has_ref_count must be false";
116
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
117
        << "list_ptr1->_needs_release must be true";
118

119
    // Verify tlh1 ThreadsList has the right field values:
120
    EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)0)
121
        << "list_ptr1->list()->_nested_handle_cnt must be 0";
122
  } // destroy tlh1
123

124
  // Test case: after first ThreadsListHandle (tlh1) has been destroyed
125
  //
126

127
  // Verify the current thread refers to no ThreadsListHandle:
128
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
129
      << "thr->_threads_hazard_ptr must match be NULL";
130
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), (SafeThreadsListPtr*) NULL)
131
      << "thr->_threads_list_ptr must be NULL";
132
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
133
      << "thr->_nested_threads_hazard_ptr_cnt must be 0";
134

135
  // Test case: first ThreadsListHandle to prepare for nesting
136
  //
137
  {
138
    ThreadsListHandle tlh1;
139
    SafeThreadsListPtr* list_ptr1 = ThreadsListHandleTest::get_TLH_list_ptr(&tlh1);
140

141
    // Verify the current thread refers to tlh1:
142
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh1.list())
143
        << "thr->_threads_hazard_ptr must match tlh1.list()";
144
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
145
        << "thr->_threads_list_ptr must match list_ptr1";
146
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
147
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
148

149
    // Verify tlh1 has the right field values:
150
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
151
        << "list_ptr1->previous() must be NULL";
152
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
153
        << "list_ptr1->_thread must match current thread";
154
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
155
        << "list_ptr1->list() must match tlh1.list()";
156
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), false)
157
        << "list_ptr1->_has_ref_count must be false";
158
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
159
        << "list_ptr1->_needs_release must be true";
160

161
    // Verify tlh1 ThreadsList has the right field values:
162
    EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)0)
163
        << "list_ptr1->list()->_nested_handle_cnt must be 0";
164

165
    // Test case: first nested ThreadsListHandle
166
    //
167
    {
168
      ThreadsListHandle tlh2;
169
      SafeThreadsListPtr* list_ptr2 = ThreadsListHandleTest::get_TLH_list_ptr(&tlh2);
170

171
      // Verify the current thread refers to tlh2:
172
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh2.list())
173
          << "thr->_threads_hazard_ptr must match tlh2.list()";
174
      EXPECT_EQ(tlh1.list(), tlh2.list())
175
          << "tlh1.list() must match tlh2.list()";
176
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr2)
177
          << "thr->_threads_list_ptr must match list_ptr2";
178
      EXPECT_NE(list_ptr1, list_ptr2)
179
          << "list_ptr1 must not match list_ptr2";
180
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)1)
181
          << "thr->_nested_threads_hazard_ptr_cnt must be 1";
182

183
      // Verify tlh2 has the right field values:
184
      EXPECT_EQ(list_ptr2->previous(), list_ptr1)
185
          << "list_ptr2->previous() must be list_ptr1";
186
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr2), thr)
187
          << "list_ptr2->_thread must match current thread";
188
      EXPECT_EQ(list_ptr2->list(), tlh2.list())
189
          << "list_ptr2->list() must match tlh2.list()";
190
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr2), false)
191
          << "list_ptr2->_has_ref_count must be false";
192
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr2), true)
193
          << "list_ptr2->_needs_release must be true";
194

195
      // Verify tlh1 has the right field values:
196
      EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
197
          << "list_ptr1->previous() must be NULL";
198
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
199
          << "list_ptr1->_thread must match current thread";
200
      EXPECT_EQ(list_ptr1->list(), tlh1.list())
201
          << "list_ptr1->list() must match tlh1.list()";
202
      // When tlh2 was created, tlh1's _has_ref_count was set to true and
203
      // tlh1's list->_nested_handle_cnt was incremented.
204
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
205
          << "list_ptr1->_has_ref_count must be true";
206
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
207
          << "list_ptr1->_needs_release must be true";
208

209
      // Verify tlh1 ThreadsList has the right field values:
210
      EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
211
          << "list_ptr1->list()->_nested_handle_cnt must be 1";
212
    } // destroy tlh2
213

214
    // Test case: after first nested ThreadsListHandle (tlh2) has been destroyed
215

216
    // Verify the current thread's hazard ptr is NULL:
217
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
218
        << "thr->_threads_hazard_ptr must be NULL";
219
    // Verify the current thread's threads list ptr refers to tlh1:
220
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
221
        << "thr->_threads_list_ptr must match list_ptr1";
222
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
223
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
224

225
    // Verify tlh1 has the right field values:
226
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
227
        << "list_ptr1->previous() must be NULL";
228
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
229
        << "list_ptr1->_thread must match current thread";
230
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
231
        << "list_ptr1->list() must match tlh1.list()";
232
    // When tlh2 was created, tlh1's _has_ref_count was set to true and
233
    // tlh1's list->_nested_handle_cnt was incremented.
234
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
235
        << "list_ptr1->_has_ref_count must be true";
236
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
237
        << "list_ptr1->_needs_release must be true";
238

239
      // Verify tlh1 ThreadsList has the right field values:
240
      EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
241
          << "list_ptr1->list()->_nested_handle_cnt must be 1";
242
  } // destroy tlh1
243

244
  // Test case: after first ThreadsListHandle to prepare for nesting has been destroyed
245
  //
246

247
  // Verify the current thread refers to no ThreadsListHandle:
248
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
249
      << "thr->_threads_hazard_ptr must match be NULL";
250
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), (SafeThreadsListPtr*) NULL)
251
      << "thr->_threads_list_ptr must be NULL";
252
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
253
      << "thr->_nested_threads_hazard_ptr_cnt must be 0";
254

255
  // Test case: first ThreadsListHandle to prepare for double nesting
256
  //
257
  {
258
    ThreadsListHandle tlh1;
259
    SafeThreadsListPtr* list_ptr1 = ThreadsListHandleTest::get_TLH_list_ptr(&tlh1);
260

261
    // Verify the current thread refers to tlh1:
262
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh1.list())
263
        << "thr->_threads_hazard_ptr must match tlh1.list()";
264
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
265
        << "thr->_threads_list_ptr must match list_ptr1";
266
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
267
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
268

269
    // Verify tlh1 has the right field values:
270
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
271
        << "list_ptr1->previous() must be NULL";
272
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
273
        << "list_ptr1->_thread must match current thread";
274
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
275
        << "list_ptr1->list() must match tlh1.list()";
276
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), false)
277
        << "list_ptr1->_has_ref_count must be false";
278
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
279
        << "list_ptr1->_needs_release must be true";
280

281
    // Verify tlh1 ThreadsList has the right field values:
282
    EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)0)
283
        << "list_ptr1->list()->_nested_handle_cnt must be 0";
284

285
    // Test case: first nested ThreadsListHandle
286
    //
287
    {
288
      ThreadsListHandle tlh2;
289
      SafeThreadsListPtr* list_ptr2 = ThreadsListHandleTest::get_TLH_list_ptr(&tlh2);
290

291
      // Verify the current thread refers to tlh2:
292
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh2.list())
293
          << "thr->_threads_hazard_ptr must match tlh2.list()";
294
      EXPECT_EQ(tlh1.list(), tlh2.list())
295
          << "tlh1.list() must match tlh2.list()";
296
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr2)
297
          << "thr->_threads_list_ptr must match list_ptr2";
298
      EXPECT_NE(list_ptr1, list_ptr2)
299
          << "list_ptr1 must not match list_ptr2";
300
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)1)
301
          << "thr->_nested_threads_hazard_ptr_cnt must be 1";
302

303
      // Verify tlh2 has the right field values:
304
      EXPECT_EQ(list_ptr2->previous(), list_ptr1)
305
          << "list_ptr2->previous() must be list_ptr1";
306
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr2), thr)
307
          << "list_ptr2->_thread must match current thread";
308
      EXPECT_EQ(list_ptr2->list(), tlh2.list())
309
          << "list_ptr2->list() must match tlh2.list()";
310
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr2), false)
311
          << "list_ptr2->_has_ref_count must be false";
312
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr2), true)
313
          << "list_ptr2->_needs_release must be true";
314

315
      // Verify tlh1 has the right field values:
316
      EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
317
          << "list_ptr1->previous() must be NULL";
318
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
319
          << "list_ptr1->_thread must match current thread";
320
      EXPECT_EQ(list_ptr1->list(), tlh1.list())
321
          << "list_ptr1->list() must match tlh1.list()";
322
      // When tlh2 was created, tlh1's _has_ref_count was set to true and
323
      // tlh1's list->_nested_handle_cnt was incremented.
324
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
325
          << "list_ptr1->_has_ref_count must be true";
326
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
327
          << "list_ptr1->_needs_release must be true";
328

329
      // Verify tlh1 ThreadsList has the right field values:
330
      EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
331
          << "list_ptr1->list()->_nested_handle_cnt must be 1";
332

333
      // Test case: double nested ThreadsListHandle
334
      //
335
      {
336
        ThreadsListHandle tlh3;
337
        SafeThreadsListPtr* list_ptr3 = ThreadsListHandleTest::get_TLH_list_ptr(&tlh3);
338

339
        // Verify the current thread refers to tlh3:
340
        EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh3.list())
341
            << "thr->_threads_hazard_ptr must match tlh3.list()";
342
        EXPECT_EQ(tlh1.list(), tlh3.list())
343
            << "tlh1.list() must match tlh3.list()";
344
        EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr3)
345
            << "thr->_threads_list_ptr must match list_ptr3";
346
        EXPECT_NE(list_ptr1, list_ptr3)
347
            << "list_ptr1 must not match list_ptr3";
348
        EXPECT_NE(list_ptr2, list_ptr3)
349
            << "list_ptr. must not match list_ptr3";
350
        EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)2)
351
            << "thr->_nested_threads_hazard_ptr_cnt must be 2";
352

353
        // Verify tlh3 has the right field values:
354
        EXPECT_EQ(list_ptr3->previous(), list_ptr2)
355
            << "list_ptr3->previous() must be list_ptr2";
356
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr3), thr)
357
            << "list_ptr3->_thread must match current thread";
358
        EXPECT_EQ(list_ptr3->list(), tlh3.list())
359
            << "list_ptr3->list() must match tlh3.list()";
360
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr3), false)
361
            << "list_ptr3->_has_ref_count must be false";
362
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr3), true)
363
            << "list_ptr3->_needs_release must be true";
364

365
        // Verify tlh2 has the right field values:
366
        EXPECT_EQ(list_ptr2->previous(), list_ptr1)
367
            << "list_ptr2->previous() must be list_ptr1";
368
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr2), thr)
369
            << "list_ptr2->_thread must match current thread";
370
        EXPECT_EQ(list_ptr2->list(), tlh2.list())
371
            << "list_ptr2->list() must match tlh2.list()";
372
        // When tlh3 was created, tlh2's _has_ref_count was set to true and
373
        // tlh2's list->_nested_handle_cnt was incremented.
374
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr2), true)
375
            << "list_ptr2->_has_ref_count must be true";
376
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr2), true)
377
            << "list_ptr2->_needs_release must be true";
378

379
        // Verify tlh1 has the right field values:
380
        EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
381
            << "list_ptr1->previous() must be NULL";
382
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
383
            << "list_ptr1->_thread must match current thread";
384
        EXPECT_EQ(list_ptr1->list(), tlh1.list())
385
            << "list_ptr1->list() must match tlh1.list()";
386
        // When tlh2 was created, tlh1's _has_ref_count was set to true and
387
        // tlh1's list->_nested_handle_cnt was incremented.
388
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
389
            << "list_ptr1->_has_ref_count must be true";
390
        EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
391
            << "list_ptr1->_needs_release must be true";
392

393
        // Verify tlh1 ThreadsList has the right field values:
394
        EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)2)
395
            << "list_ptr1->list()->_nested_handle_cnt must be 2";
396
      } // destroy tlh3
397

398
      // Test case: after double nested ThreadsListHandle (tlh3) has been destroyed
399

400
      // Verify the current thread's hazard ptr is NULL:
401
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
402
          << "thr->_threads_hazard_ptr must be NULL";
403
      // Verify the current thread's threads list ptr refers to tlh2:
404
      EXPECT_EQ(tlh1.list(), tlh2.list())
405
          << "tlh1.list() must match tlh2.list()";
406
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr2)
407
          << "thr->_threads_list_ptr must match list_ptr2";
408
      EXPECT_NE(list_ptr1, list_ptr2)
409
          << "list_ptr1 must not match list_ptr2";
410
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)1)
411
          << "thr->_nested_threads_hazard_ptr_cnt must be 1";
412

413
      // Verify tlh2 has the right field values:
414
      EXPECT_EQ(list_ptr2->previous(), list_ptr1)
415
          << "list_ptr2->previous() must be list_ptr1";
416
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr2), thr)
417
          << "list_ptr2->_thread must match current thread";
418
      EXPECT_EQ(list_ptr2->list(), tlh2.list())
419
          << "list_ptr2->list() must match tlh2.list()";
420
      // When tlh3 was created, tlh2's _has_ref_count was set to true and
421
      // tlh2's list->_nested_handle_cnt was incremented.
422
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr2), true)
423
          << "list_ptr2->_has_ref_count must be true";
424
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr2), true)
425
          << "list_ptr2->_needs_release must be true";
426

427
      // Verify tlh1 has the right field values:
428
      EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
429
          << "list_ptr1->previous() must be NULL";
430
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
431
          << "list_ptr1->_thread must match current thread";
432
      EXPECT_EQ(list_ptr1->list(), tlh1.list())
433
          << "list_ptr1->list() must match tlh1.list()";
434
      // When tlh2 was created, tlh1's _has_ref_count was set to true and
435
      // tlh1's list->_nested_handle_cnt was incremented.
436
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
437
          << "list_ptr1->_has_ref_count must be true";
438
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
439
          << "list_ptr1->_needs_release must be true";
440

441
      // Verify tlh1 ThreadsList has the right field values:
442
      EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)2)
443
          << "list_ptr1->list()->_nested_handle_cnt must be 2";
444
    } // destroy tlh2
445

446
    // Test case: after first nested ThreadsListHandle (tlh2) has been destroyed
447

448
    // Verify the current thread's hazard ptr is NULL:
449
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
450
        << "thr->_threads_hazard_ptr must be NULL";
451
    // Verify the current thread's threads list ptr refers to tlh1:
452
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
453
        << "thr->_threads_list_ptr must match list_ptr1";
454
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
455
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
456

457
    // Verify tlh1 has the right field values:
458
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
459
        << "list_ptr1->previous() must be NULL";
460
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
461
        << "list_ptr1->_thread must match current thread";
462
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
463
        << "list_ptr1->list() must match tlh1.list()";
464
    // When tlh2 was created, tlh1's _has_ref_count was set to true and
465
    // tlh1's list->_nested_handle_cnt was incremented.
466
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
467
        << "list_ptr1->_has_ref_count must be true";
468
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
469
        << "list_ptr1->_needs_release must be true";
470

471
    // Verify tlh1 ThreadsList has the right field values:
472
    EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
473
        << "list_ptr1->list()->_nested_handle_cnt must be 1";
474
  } // destroy tlh1
475

476
  // Test case: after first ThreadsListHandle to prepare for double nesting has been destroyed
477
  //
478

479
  // Verify the current thread refers to no ThreadsListHandle:
480
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
481
      << "thr->_threads_hazard_ptr must match be NULL";
482
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), (SafeThreadsListPtr*) NULL)
483
      << "thr->_threads_list_ptr must be NULL";
484
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
485
      << "thr->_nested_threads_hazard_ptr_cnt must be 0";
486

487
  // Test case: first ThreadsListHandle to prepare for back-to-back nesting
488
  //
489
  {
490
    ThreadsListHandle tlh1;
491
    SafeThreadsListPtr* list_ptr1 = ThreadsListHandleTest::get_TLH_list_ptr(&tlh1);
492

493
    // Verify the current thread refers to tlh1:
494
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh1.list())
495
        << "thr->_threads_hazard_ptr must match tlh1.list()";
496
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
497
        << "thr->_threads_list_ptr must match list_ptr1";
498
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
499
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
500

501
    // Verify tlh1 has the right field values:
502
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
503
        << "list_ptr1->previous() must be NULL";
504
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
505
        << "list_ptr1->_thread must match current thread";
506
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
507
        << "list_ptr1->list() must match tlh1.list()";
508
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), false)
509
        << "list_ptr1->_has_ref_count must be false";
510
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
511
        << "list_ptr1->_needs_release must be true";
512

513
    // Verify tlh1 ThreadsList has the right field values:
514
    EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)0)
515
        << "list_ptr1->list()->_nested_handle_cnt must be 0";
516

517
    // Test case: first back-to-back nested ThreadsListHandle
518
    //
519
    {
520
      ThreadsListHandle tlh2a;
521
      SafeThreadsListPtr* list_ptr2a = ThreadsListHandleTest::get_TLH_list_ptr(&tlh2a);
522

523
      // Verify the current thread refers to tlh2a:
524
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh2a.list())
525
          << "thr->_threads_hazard_ptr must match tlh2a.list()";
526
      EXPECT_EQ(tlh1.list(), tlh2a.list())
527
          << "tlh1.list() must match tlh2a.list()";
528
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr2a)
529
          << "thr->_threads_list_ptr must match list_ptr2a";
530
      EXPECT_NE(list_ptr1, list_ptr2a)
531
          << "list_ptr1 must not match list_ptr2a";
532
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)1)
533
          << "thr->_nested_threads_hazard_ptr_cnt must be 1";
534

535
      // Verify tlh2a has the right field values:
536
      EXPECT_EQ(list_ptr2a->previous(), list_ptr1)
537
          << "list_ptr2a->previous() must be list_ptr1";
538
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr2a), thr)
539
          << "list_ptr2a->_thread must match current thread";
540
      EXPECT_EQ(list_ptr2a->list(), tlh2a.list())
541
          << "list_ptr2a->list() must match tlh2a.list()";
542
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr2a), false)
543
          << "list_ptr2a->_has_ref_count must be false";
544
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr2a), true)
545
          << "list_ptr2a->_needs_release must be true";
546

547
      // Verify tlh1 has the right field values:
548
      EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
549
          << "list_ptr1->previous() must be NULL";
550
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
551
          << "list_ptr1->_thread must match current thread";
552
      EXPECT_EQ(list_ptr1->list(), tlh1.list())
553
          << "list_ptr1->list() must match tlh1.list()";
554
      // When tlh2a was created, tlh1's _has_ref_count was set to true and
555
      // tlh1's list->_nested_handle_cnt was incremented.
556
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
557
          << "list_ptr1->_has_ref_count must be true";
558
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
559
          << "list_ptr1->_needs_release must be true";
560

561
      // Verify tlh1 ThreadsList has the right field values:
562
      EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
563
          << "list_ptr1->list()->_nested_handle_cnt must be 1";
564
    } // destroy tlh2a
565

566
    // Test case: after first back-to-back nested ThreadsListHandle (tlh2a) has been destroyed
567

568
    // Verify the current thread's hazard ptr is NULL:
569
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
570
        << "thr->_threads_hazard_ptr must be NULL";
571
    // Verify the current thread's threads list ptr refers to tlh1:
572
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
573
        << "thr->_threads_list_ptr must match list_ptr1";
574
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
575
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
576

577
    // Verify tlh1 has the right field values:
578
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
579
        << "list_ptr1->previous() must be NULL";
580
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
581
        << "list_ptr1->_thread must match current thread";
582
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
583
        << "list_ptr1->list() must match tlh1.list()";
584
    // When tlh2a was created, tlh1's _has_ref_count was set to true and
585
    // tlh1's list->_nested_handle_cnt was incremented.
586
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
587
        << "list_ptr1->_has_ref_count must be true";
588
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
589
        << "list_ptr1->_needs_release must be true";
590

591
    // Verify tlh1 ThreadsList has the right field values:
592
    EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
593
        << "list_ptr1->list()->_nested_handle_cnt must be 1";
594

595
    // Test case: second back-to-back nested ThreadsListHandle
596
    //
597
    {
598
      ThreadsListHandle tlh2b;
599
      SafeThreadsListPtr* list_ptr2b = ThreadsListHandleTest::get_TLH_list_ptr(&tlh2b);
600

601
      // Verify the current thread refers to tlh2b:
602
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), tlh2b.list())
603
          << "thr->_threads_hazard_ptr must match tlh2b.list()";
604
      EXPECT_EQ(tlh1.list(), tlh2b.list())
605
          << "tlh1.list() must match tlh2b.list()";
606
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr2b)
607
          << "thr->_threads_list_ptr must match list_ptr2b";
608
      EXPECT_NE(list_ptr1, list_ptr2b)
609
          << "list_ptr1 must not match list_ptr2b";
610
      EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)1)
611
          << "thr->_nested_threads_hazard_ptr_cnt must be 1";
612

613
      // Verify tlh2b has the right field values:
614
      EXPECT_EQ(list_ptr2b->previous(), list_ptr1)
615
          << "list_ptr2b->previous() must be list_ptr1";
616
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr2b), thr)
617
          << "list_ptr2b->_thread must match current thread";
618
      EXPECT_EQ(list_ptr2b->list(), tlh2b.list())
619
          << "list_ptr2b->list() must match tlh2b.list()";
620
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr2b), false)
621
          << "list_ptr2b->_has_ref_count must be false";
622
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr2b), true)
623
          << "list_ptr2b->_needs_release must be true";
624

625
      // Verify tlh1 has the right field values:
626
      EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
627
          << "list_ptr1->previous() must be NULL";
628
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
629
          << "list_ptr1->_thread must match current thread";
630
      EXPECT_EQ(list_ptr1->list(), tlh1.list())
631
          << "list_ptr1->list() must match tlh1.list()";
632
      // When tlh2a was created, tlh1's _has_ref_count was set to true and
633
      // tlh1's list->_nested_handle_cnt was incremented.
634
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
635
          << "list_ptr1->_has_ref_count must be true";
636
      EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
637
          << "list_ptr1->_needs_release must be true";
638

639
      // Verify tlh1 ThreadsList has the right field values:
640
      EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
641
          << "list_ptr1->list()->_nested_handle_cnt must be 1";
642
    } // destroy tlh2b
643

644
    // Test case: after second back-to-back nested ThreadsListHandle (tlh2b) has been destroyed
645

646
    // Verify the current thread's hazard ptr is NULL:
647
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
648
        << "thr->_threads_hazard_ptr must be NULL";
649
    // Verify the current thread's threads list ptr refers to tlh1:
650
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), list_ptr1)
651
        << "thr->_threads_list_ptr must match list_ptr1";
652
    EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
653
        << "thr->_nested_threads_hazard_ptr_cnt must be 0";
654

655
    // Verify tlh1 has the right field values:
656
    EXPECT_EQ(list_ptr1->previous(), (SafeThreadsListPtr*)NULL)
657
        << "list_ptr1->previous() must be NULL";
658
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_thread(list_ptr1), thr)
659
        << "list_ptr1->_thread must match current thread";
660
    EXPECT_EQ(list_ptr1->list(), tlh1.list())
661
        << "list_ptr1->list() must match tlh1.list()";
662
    // When tlh2a was created, tlh1's _has_ref_count was set to true and
663
    // tlh1's list->_nested_handle_cnt was incremented.
664
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_has_ref_count(list_ptr1), true)
665
        << "list_ptr1->_has_ref_count must be true";
666
    EXPECT_EQ(ThreadsListHandleTest::get_STLP_needs_release(list_ptr1), true)
667
        << "list_ptr1->_needs_release must be true";
668

669
    // Verify tlh1 ThreadsList has the right field values:
670
    EXPECT_EQ(ThreadsListHandleTest::get_TL_nested_handle_cnt(list_ptr1->list()), (intx)1)
671
        << "list_ptr1->list()->_nested_handle_cnt must be 1";
672
  } // destroy tlh1
673

674
  // Test case: after first ThreadsListHandle to prepare for back-to-back nesting has been destroyed
675
  //
676

677
  // Verify the current thread refers to no ThreadsListHandle:
678
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_hazard_ptr(thr), (ThreadsList*)NULL)
679
      << "thr->_threads_hazard_ptr must match be NULL";
680
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_threads_list_ptr(thr), (SafeThreadsListPtr*) NULL)
681
      << "thr->_threads_list_ptr must be NULL";
682
  EXPECT_EQ(ThreadsListHandleTest::get_Thread_nested_threads_hazard_ptr_cnt(thr), (uint)0)
683
      << "thr->_nested_threads_hazard_ptr_cnt must be 0";
684

685
  EnableThreadSMRStatistics = saved_flag_val;
686
}
687

688
Product

Resources

Company
