src/base/uncontended_mutex.test.cc

   1 /*
   2  * Copyright 2020 Google, Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met: redistributions of source code must retain the above copyright
   7  * notice, this list of conditions and the following disclaimer;
   8  * redistributions in binary form must reproduce the above copyright
   9  * notice, this list of conditions and the following disclaimer in the
  10  * documentation and/or other materials provided with the distribution;
  11  * neither the name of the copyright holders nor the names of its
  12  * contributors may be used to endorse or promote products derived from
  13  * this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  19  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  21  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <gtest/gtest.h>
  29 #include <mutex>
  30 #include <thread>
  31 #include <vector>
  32
  33 #include "base/uncontended_mutex.hh"
  34
  35 TEST(UncontendedMutex, Lock)
  36 {
  37     int data = 0;
  38     UncontendedMutex m;
  39
  40     std::thread t1([&] () {
  41         std::lock_guard<UncontendedMutex> g(m);
  42         // Simulate += operation with a racing change between read and write.
  43         int tmp = data;
  44         std::this_thread::sleep_for(std::chrono::milliseconds(200));
  45         data = tmp + 1;
  46     });
  47
  48     std::thread t2([&] () {
  49         std::this_thread::sleep_for(std::chrono::milliseconds(100));
  50         std::lock_guard<UncontendedMutex> g(m);
  51         data = data + 1;
  52     });
  53
  54     std::thread t3([&] () {
  55         std::this_thread::sleep_for(std::chrono::milliseconds(100));
  56         std::lock_guard<UncontendedMutex> g(m);
  57         data = data + 1;
  58     });
  59     t1.join();
  60     t2.join();
  61     t3.join();
  62
  63     EXPECT_EQ(data, 3);
  64 }
  65
  66 TEST(UncontendedMutex, HeavyContention)
  67 {
  68     int num_of_iter = 1000;
  69     int num_of_thread = 1000;
  70     std::vector<std::thread> threads;
  71
  72     int data = 0;
  73     UncontendedMutex m;
  74
  75     for (int t = 0 ; t < num_of_thread; ++t) {
  76         threads.emplace_back([&] () {
  77             for (int k = 0; k < num_of_iter; ++k) {
  78                 std::lock_guard<UncontendedMutex> g(m);
  79                 data++;
  80             }
  81         });
  82     }
  83
  84     for (auto& t : threads) {
  85         t.join();
  86     }
  87     EXPECT_EQ(data, num_of_iter * num_of_thread);
  88 }