test/unit/set/test_set_rcu.h

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
   5
   6     Source code repo: http://github.com/khizmax/libcds/
   7     Download: http://sourceforge.net/projects/libcds/files/
   8
   9     Redistribution and use in source and binary forms, with or without
  10     modification, are permitted provided that the following conditions are met:
  11
  12     * Redistributions of source code must retain the above copyright notice, this
  13       list of conditions and the following disclaimer.
  14
  15     * Redistributions in binary form must reproduce the above copyright notice,
  16       this list of conditions and the following disclaimer in the documentation
  17       and/or other materials provided with the distribution.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  23     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #ifndef CDSUNIT_SET_TEST_SET_RCU_H
  32 #define CDSUNIT_SET_TEST_SET_RCU_H
  33
  34 #include "test_set.h"
  35
  36 namespace cds_test {
  37
  38     class container_set_rcu: public container_set
  39     {
  40         typedef container_set base_class;
  41
  42     protected:
  43         template <typename Set>
  44         void test( Set& s )
  45         {
  46             // Precondition: set is empty
  47             // Postcondition: set is empty
  48
  49             ASSERT_TRUE( s.empty() );
  50             ASSERT_CONTAINER_SIZE( s, 0 );
  51
  52             base_class::test( s );
  53
  54             typedef typename Set::value_type value_type;
  55
  56             size_t const nSetSize = kSize;
  57             std::vector< value_type > data;
  58             std::vector< size_t> indices;
  59             data.reserve( kSize );
  60             indices.reserve( kSize );
  61             for ( size_t key = 0; key < kSize; ++key ) {
  62                 data.push_back( value_type( static_cast<int>(key) ) );
  63                 indices.push_back( key );
  64             }
  65             shuffle( indices.begin(), indices.end() );
  66
  67             for ( auto& i : data ) {
  68                 ASSERT_TRUE( s.insert( i ) );
  69             }
  70             ASSERT_FALSE( s.empty() );
  71             ASSERT_CONTAINER_SIZE( s, nSetSize );
  72
  73             // iterator test
  74             for ( auto it = s.begin(); it != s.end(); ++it ) {
  75                 it->nFindCount = it->key() * 3;
  76             }
  77
  78             for ( auto it = s.cbegin(); it != s.cend(); ++it ) {
  79                 EXPECT_EQ( it->nFindCount, it->key() * 3 );
  80             }
  81
  82             typedef typename Set::exempt_ptr exempt_ptr;
  83             typedef typename Set::raw_ptr    raw_ptr;
  84             typedef typename Set::rcu_lock   rcu_lock;
  85
  86             // get()
  87             for ( auto idx : indices ) {
  88                 auto& i = data[idx];
  89
  90                 {
  91                     rcu_lock l;
  92                     raw_ptr  rp;
  93                     ASSERT_TRUE( !rp );
  94                     switch ( idx % 3 ) {
  95                     case 0:
  96                         rp = s.get( i.key() );
  97                         ASSERT_FALSE( !rp );
  98                         break;
  99                     case 1:
 100                         rp = s.get( i );
 101                         ASSERT_FALSE( !rp );
 102                         break;
 103                     case 2:
 104                         rp = s.get_with( other_item( i.key() ), other_less() );
 105                         ASSERT_FALSE( !rp );
 106                     }
 107                     EXPECT_EQ( rp->key(), i.key() );
 108                     EXPECT_EQ( rp->nFindCount, i.key() * 3 );
 109                     rp->nFindCount *= 2;
 110                 }
 111             }
 112
 113             // extract()
 114             exempt_ptr xp;
 115             for ( auto idx : indices ) {
 116                 auto& i = data[idx];
 117
 118                 ASSERT_TRUE( !xp );
 119                 if ( Set::c_bExtractLockExternal ) {
 120                     rcu_lock l;
 121
 122                     switch ( idx % 3 ) {
 123                     case 0:
 124                         xp = s.extract( i.key() );
 125                         ASSERT_FALSE( !xp );
 126                         break;
 127                     case 1:
 128                         xp = s.extract( i );
 129                         ASSERT_FALSE( !xp );
 130                         break;
 131                     case 2:
 132                         xp = s.extract_with( other_item( i.key() ), other_less() );
 133                         ASSERT_FALSE( !xp );
 134                         break;
 135                     }
 136                     EXPECT_EQ( xp->key(), i.key() );
 137                     EXPECT_EQ( xp->nFindCount, i.key() * 6 );
 138
 139                     switch ( idx % 3 ) {
 140                     case 0:
 141                         xp = s.extract( i.key() );
 142                         break;
 143                     case 1:
 144                         xp = s.extract( i );
 145                         break;
 146                     case 2:
 147                         xp = s.extract_with( other_item( i.key() ), other_less() );
 148                         break;
 149                     }
 150                     ASSERT_TRUE( !xp );
 151                 }
 152                 else {
 153                     switch ( idx % 3 ) {
 154                     case 0:
 155                         xp = s.extract( i.key() );
 156                         ASSERT_FALSE( !xp );
 157                         break;
 158                     case 1:
 159                         xp = s.extract( i );
 160                         ASSERT_FALSE( !xp );
 161                         break;
 162                     case 2:
 163                         xp = s.extract_with( other_item( i.key() ), other_less() );
 164                         ASSERT_FALSE( !xp );
 165                         break;
 166                     }
 167                     EXPECT_EQ( xp->key(), i.key() );
 168                     EXPECT_EQ( xp->nFindCount, i.key() * 6 );
 169
 170                     switch ( idx % 3 ) {
 171                     case 0:
 172                         xp = s.extract( i.key() );
 173                         break;
 174                     case 1:
 175                         xp = s.extract( i );
 176                         break;
 177                     case 2:
 178                         xp = s.extract_with( other_item( i.key() ), other_less() );
 179                         break;
 180                     }
 181                     ASSERT_TRUE( !xp );
 182                 }
 183             }
 184
 185             ASSERT_TRUE( s.empty() );
 186             ASSERT_CONTAINER_SIZE( s, 0 );
 187         }
 188
 189     };
 190 } // namespace cds_test
 191
 192 #endif // CDSUNIT_SET_TEST_SET_RCU_H