Fixed doxygen 1.8.10 incompabilities

diff --git a/cds/container/lazy_kvlist_nogc.h b/cds/container/lazy_kvlist_nogc.h
index bcb5f59977e824e185420f6246a911dd4de4aeff..77d38897bfdbc008763c8e83bad1bd7b8015d6aa 100644 (file)
--- a/cds/container/lazy_kvlist_nogc.h
+++ b/cds/container/lazy_kvlist_nogc.h
@@ -15,9 +15,9 @@ namespace cds { namespace container {
         @anchor cds_nonintrusive_LazyKVList_nogc
 
         This specialization is append-only list when no item
-        reclamation may be performed. The class does not support deleting of list item.
+        reclamation may be performed. The class does not support deleting of list's item.
 
-        @copydetails cds_nonintrusive_LazyList_gc
+        See @ref cds_nonintrusive_LazyList_gc "cds::container::LazyList<cds::gc::nogc, T, Traits>"
     */
     template <
         typename Key,

diff --git a/cds/container/lazy_list_nogc.h b/cds/container/lazy_list_nogc.h
index d32c84a7101505b2aef94a71f7b7f2ddee798b8b..979d47ce9131a5fd08e3c921cae2ca288f6f83cf 100644 (file)
--- a/cds/container/lazy_list_nogc.h
+++ b/cds/container/lazy_list_nogc.h
@@ -22,7 +22,7 @@ namespace cds { namespace container {
         relationship (\p Traits::equal_to), but for the ordered list \p less
         or \p compare relations should be specified in \p Traits.
 
-        @copydetails cds_nonintrusive_LazyList_gc
+        See @ref cds_nonintrusive_LazyList_gc "cds::container::LazyList<cds::gc::nogc, T, Traits>"
     */
     template <
         typename T,

diff --git a/cds/container/michael_map_nogc.h b/cds/container/michael_map_nogc.h
index a85dd62ddf65f2c364b507e23c7331fd2d590cf9..f30af09ed4e7ab4c908166a0a36e1a8a467da42f 100644 (file)
--- a/cds/container/michael_map_nogc.h
+++ b/cds/container/michael_map_nogc.h
@@ -16,7 +16,7 @@ namespace cds { namespace container {
         This specialization is so-called append-only when no item
         reclamation may be performed. The class does not support deleting of map item.
 
-        See \ref cds_nonintrusive_MichaelHashMap_hp "MichaelHashMap" for description of template parameters.
+        See @ref cds_nonintrusive_MichaelHashMap_hp "MichaelHashMap" for description of template parameters.
     */
     template <
         class OrderedList,
@@ -250,7 +250,14 @@ namespace cds { namespace container {
 
     public:
         /// Initialize the map
-        /** @copydetails cds_nonintrusive_MichaelHashMap_hp_ctor
+        /**
+            The Michael's hash map is non-expandable container. You should point the average count of items \p nMaxItemCount
+            when you create an object.
+            \p nLoadFactor parameter defines average count of items per bucket and it should be small number between 1 and 10.
+            Remember, since the bucket implementation is an ordered list, searching in the bucket is linear [<tt>O(nLoadFactor)</tt>].
+            Note, that many popular STL hash map implementation uses load factor 1.
+
+            The ctor defines hash table size as rounding <tt>nMacItemCount / nLoadFactor</tt> up to nearest power of two.
         */
         MichaelHashMap(
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set

diff --git a/cds/container/michael_map_rcu.h b/cds/container/michael_map_rcu.h
index 8bbb220875334b74f517b33657cc1b760cf5c0ab..edd82bdc2f321f72deeecfde1db2a11c26a506e9 100644 (file)
--- a/cds/container/michael_map_rcu.h
+++ b/cds/container/michael_map_rcu.h
@@ -286,7 +286,14 @@ namespace cds { namespace container {
 
     public:
         /// Initializes the map
-        /** @copydetails cds_nonintrusive_MichaelHashMap_hp_ctor
+        /**
+            The Michael's hash map is non-expandable container. You should point the average count of items \p nMaxItemCount
+            when you create an object.
+            \p nLoadFactor parameter defines average count of items per bucket and it should be small number between 1 and 10.
+            Remember, since the bucket implementation is an ordered list, searching in the bucket is linear [<tt>O(nLoadFactor)</tt>].
+            Note, that many popular STL hash map implementation uses load factor 1.
+
+            The ctor defines hash table size as rounding <tt>nMacItemCount / nLoadFactor</tt> up to nearest power of two.
         */
         MichaelHashMap(
             size_t nMaxItemCount,   ///< estimation of max item count in the hash map

diff --git a/cds/container/michael_set_nogc.h b/cds/container/michael_set_nogc.h
index b1cc933243cb583735ebc2843d2d2907ec09773f..ce0dc31c25ca80a0376a7cdbd4c8c1b600140a6d 100644 (file)
--- a/cds/container/michael_set_nogc.h
+++ b/cds/container/michael_set_nogc.h
@@ -155,7 +155,13 @@ namespace cds { namespace container {
 
     public:
         /// Initialize hash set
-        /** @copydetails cds_nonintrusive_MichaelHashSet_hp_ctor
+        /**
+            The Michael's hash set is non-expandable container. You should point the average count of items \p nMaxItemCount
+            when you create an object.
+            \p nLoadFactor parameter defines average count of items per bucket and it should be small number between 1 and 10.
+            Remember, since the bucket implementation is an ordered list, searching in the bucket is linear [<tt>O(nLoadFactor)</tt>].
+
+            The ctor defines hash table size as rounding <tt>nMaxItemCount / nLoadFactor</tt> up to nearest power of two.
         */
         MichaelHashSet(
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set

diff --git a/cds/container/michael_set_rcu.h b/cds/container/michael_set_rcu.h
index 501d43933df5e8280f66110c899a513d640687f9..868ae8906d5ca6303277a703c49c396f074829bd 100644 (file)
--- a/cds/container/michael_set_rcu.h
+++ b/cds/container/michael_set_rcu.h
@@ -238,7 +238,13 @@ namespace cds { namespace container {
 
     public:
         /// Initialize hash set
-        /** @copydetails cds_nonintrusive_MichaelHashSet_hp_ctor
+        /**
+            The Michael's hash set is non-expandable container. You should point the average count of items \p nMaxItemCount
+            when you create an object.
+            \p nLoadFactor parameter defines average count of items per bucket and it should be small number between 1 and 10.
+            Remember, since the bucket implementation is an ordered list, searching in the bucket is linear [<tt>O(nLoadFactor)</tt>].
+
+            The ctor defines hash table size as rounding <tt>nMaxItemCount / nLoadFactor</tt> up to nearest power of two.
         */
         MichaelHashSet(
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set

diff --git a/cds/container/segmented_queue.h b/cds/container/segmented_queue.h
index ce75b2efa868fc0f8b0036c6071c7876ec55c651..48c26d6607e83dcf0466a1d218e3864bc1f35556 100644 (file)
--- a/cds/container/segmented_queue.h
+++ b/cds/container/segmented_queue.h
@@ -47,7 +47,11 @@ namespace cds { namespace container {
             enum { alignment = opt::cache_line_alignment };
 
             /// Padding of segment data, default is no special padding
-            /** @copydetails cds::intrusive::segmented_queue::traits::padding
+            /**
+                The segment is just an array of atomic data pointers,
+                so, the high load leads to false sharing and performance degradation.
+                A padding of segment data can eliminate false sharing issue.
+                On the other hand, the padding leads to increase segment size.
             */
             enum { padding = cds::intrusive::segmented_queue::traits::padding };
 

diff --git a/cds/intrusive/michael_set_nogc.h b/cds/intrusive/michael_set_nogc.h
index f64ec3f6a623fe8eceefffc317754377f527ac22..dd08d821a320529db36d4d9327e4a81291bbad05 100644 (file)
--- a/cds/intrusive/michael_set_nogc.h
+++ b/cds/intrusive/michael_set_nogc.h
@@ -138,7 +138,12 @@ namespace cds { namespace intrusive {
 
     public:
         /// Initializes hash set
-        /** @copydetails cds_intrusive_MichaelHashSet_hp_ctor
+        /**
+            The Michael's hash set is an unbounded container, but its hash table is non-expandable.
+            At construction time you should pass estimated maximum item count and a load factor.
+            The load factor is average size of one bucket - a small number between 1 and 10.
+            The bucket is an ordered single-linked list, searching in the bucket has linear complexity <tt>O(nLoadFactor)</tt>.
+            The constructor defines hash table size as rounding <tt>nMaxItemCount / nLoadFactor</tt> up to nearest power of two.
         */
         MichaelHashSet(
             size_t nMaxItemCount,   ///< estimation of max item count in the hash set