cds/container/details/lazy_list_base.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 CDSLIB_CONTAINER_DETAILS_LAZY_LIST_BASE_H
  32 #define CDSLIB_CONTAINER_DETAILS_LAZY_LIST_BASE_H
  33
  34 #include <cds/container/details/base.h>
  35 #include <cds/intrusive/details/lazy_list_base.h>
  36 #include <cds/urcu/options.h>
  37
  38 namespace cds { namespace container {
  39
  40     /// LazyList ordered list related definitions
  41     /** @ingroup cds_nonintrusive_helper
  42     */
  43     namespace lazy_list {
  44         /// LazyList traits
  45         /**
  46             Either \p compare or \p less or both must be specified.
  47         */
  48         struct traits
  49         {
  50             /// allocator used to allocate new node
  51             typedef CDS_DEFAULT_ALLOCATOR   allocator;
  52
  53             /// Key comparing functor
  54             /**
  55                 No default functor is provided. If the option is not specified, the \p less is used.
  56             */
  57             typedef opt::none                       compare;
  58
  59             /// Specifies binary predicate used for key comparing
  60             /**
  61                 Default is \p std::less<T>.
  62             */
  63             typedef opt::none                       less;
  64
  65             /// Specifies binary functor used for comparing keys for equality
  66             /**
  67                 No default functor is provided. If \p equal_to option is not spcified, \p compare is used, if \p compare is not
  68                 specified, \p less is used.
  69             */
  70             typedef opt::none                       equal_to;
  71
  72             /// Specifies list ordering policy.
  73             /**
  74                 If \p sort is \p true, than list maintains items in sorted order, otherwise items are unordered. Default is \p true.
  75                 Note that if \p sort is \p false then lookup operations scan entire list.
  76             */
  77             static const bool sort = true;
  78
  79             /// Lock type used to lock modifying items
  80             /**
  81                 Default is cds::sync::spin
  82             */
  83             typedef cds::sync::spin                 lock_type;
  84
  85             /// back-off strategy used
  86             typedef cds::backoff::Default           back_off;
  87
  88             /// Item counting feature; by default, disabled. Use \p cds::atomicity::item_counter to enable item counting
  89             typedef atomicity::empty_item_counter     item_counter;
  90
  91             /// C++ memory ordering model
  92             /**
  93                 Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
  94                 or \p opt::v::sequential_consistent (sequentially consisnent memory model).
  95             */
  96             typedef opt::v::relaxed_ordering        memory_model;
  97
  98             /// RCU deadlock checking policy (only for \ref cds_intrusive_LazyList_rcu "RCU-based LazyList")
  99             /**
 100                 List of available options see \p opt::rcu_check_deadlock
 101             */
 102             typedef opt::v::rcu_throw_deadlock      rcu_check_deadlock;
 103
 104             //@cond
 105             // LazyKVList: supporting for split-ordered list
 106             // key accessor (opt::none = internal key type is equal to user key type)
 107             typedef opt::none                       key_accessor;
 108
 109             //@endcond
 110         };
 111
 112         /// Metafunction converting option list to \p lazy_list::traits
 113         /**
 114             \p Options are:
 115             - \p opt::lock_type - lock type for node-level locking. Default \p is cds::sync::spin. Note that <b>each</b> node
 116                 of the list has member of type \p lock_type, therefore, heavy-weighted locking primitive is not
 117                 acceptable as candidate for \p lock_type.
 118             - \p opt::compare - key compare functor. No default functor is provided.
 119                 If the option is not specified, the \p opt::less is used.
 120             - \p opt::less - specifies binary predicate used for key compare. Default is \p std::less<T>.
 121             - \p opt::equal_to - specifies binary functor for comparing keys for equality. This option is applicable only for unordered list.
 122                 No default is provided. If \p equal_to is not specified, \p compare is used, if \p compare is not specified, \p less is used.
 123             - \p opt::sort - specifies ordering policy. Default value is \p true, i.e. the list is ordered.
 124                 Note: unordering feature is not fully supported yet.
 125             - \p opt::back_off - back-off strategy used. If the option is not specified, \p cds::backoff::Default is used.
 126             - \p opt::item_counter - the type of item counting feature. Default is disabled (\p atomicity::empty_item_counter).
 127                 To enable item counting use \p atomicity::item_counter.
 128             - \p opt::allocator - the allocator used for creating and freeing list's item. Default is \ref CDS_DEFAULT_ALLOCATOR macro.
 129             - \p opt::memory_model - C++ memory ordering model. Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
 130                 or \p opt::v::sequential_consistent (sequentially consisnent memory model).
 131         */
 132         template <typename... Options>
 133         struct make_traits {
 134 #   ifdef CDS_DOXYGEN_INVOKED
 135             typedef implementation_defined type ;   ///< Metafunction result
 136 #   else
 137             typedef typename cds::opt::make_options<
 138                 typename cds::opt::find_type_traits< traits, Options... >::type
 139                 ,Options...
 140             >::type   type;
 141 #endif
 142         };
 143
 144
 145     } // namespace lazy_list
 146
 147     // Forward declarations
 148     template <typename GC, typename T, typename Traits=lazy_list::traits>
 149     class LazyList;
 150
 151     template <typename GC, typename Key, typename Value, typename Traits=lazy_list::traits>
 152     class LazyKVList;
 153
 154     // Tag for selecting lazy list implementation
 155     /**
 156         This struct is empty and it is used only as a tag for selecting LazyList
 157         as ordered list implementation in declaration of some classes.
 158
 159         See \p split_list::traits::ordered_list as an example.
 160     */
 161     struct lazy_list_tag
 162     {};
 163
 164 }}  // namespace cds::container
 165
 166
 167 #endif  // #ifndef CDSLIB_CONTAINER_DETAILS_LAZY_LIST_BASE_H