libcds-user — User mail list

[Libcds-user] Double free error with FCPriority queue

[Amila J. <the...@gm...>]

Hello,

I am having an issue with FCPriority queue.

In my code I need to allocate memory for FCPriority queue in a thread in
heap. Then in the destructor, I delete the allocated pointer. The
destructor is called in the main thread. During destructor call of my class
object, I get a double free error. The -fsanitize=address output is given
in [1]. I tested with both 1.6.0 and 2.1 and encountered the same error.

Please advise me how to resolve the issue.

[1] http://pastebin.com/FH7wSTCQ

Thank you
Regards
-Thejaka

Re: [Libcds-user] build of libcds-1.4.0 tests failed under Linux Mint 15 (Ubuntu 13.04) with g++ 4.7.3

[Max K. <kh...@gm...>]

Hi Alexey,

Thanks for message.
I've create ticket No12 (http://sourceforge.net/p/libcds/bugs/12/) for 
this problem

BR
     Max

On 10/04/2013 10:06 AM, ??????? ????? wrote:
>
> I have tried to build the library/tests: "build.sh -p amd64 -o linux 
> -b 64". Libraries .so were built successfully, but tests weren't
>
> g++ -std=c++0x -c -DNDEBUG -O3 -fno-strict-aliasing   -m64 -fPIC 
> -march=native    -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS 
> -D_FILE_OFFSET_BITS=64 -I.. -I../tests/test-hdr -I../tests 
> ../tests/test-hdr/map/hdr_refinable_hashmap_map.cpp -o 
> ../tests/test-hdr/map/hdr_refinable_hashmap_map.o
>
> In file included from 
> ../tests/test-hdr/map/hdr_refinable_hashmap_map.cpp:13:0:
>
> ../cds/container/striped_map/std_map.h: In instantiation of 'bool 
> cds::intrusive::striped_set::adapt<std::map<_Key, _Tp, _Compare, 
> _Alloc>, Options ...>::adapted_container::emplace(Q&&, Args&& ...) 
> [with Q = int; Args = {}; Key = int; T = 
> map::StripedMapHdrTest::value_type; Traits = 
> map::StripedMapHdrTest::less; Alloc = std::allocator<std::pair<const 
> int, map::StripedMapHdrTest::value_type> >; Options = 
> {cds::opt::type_traits<cds::container::details::make_striped_map<std::map<int, 
> map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>, 
> cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex, 
> cds::backoff::yield, std::allocator<int> > >, 
> cds::opt::hash<map::StripedMapHdrTest::hash_int>, 
> cds::opt::less<map::StripedMapHdrTest::less>, 
> cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul> 
> > >::options>}]':
>
> ../cds/container/striped_map.h:728:17: required from 'bool 
> cds::container::StripedMap<Container, Options>::emplace(K&&, Args&& 
> ...) [with K = int; Args = {}; Container = std::map<int, 
> map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>; 
> Options = 
> {cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex, 
> cds::backoff::yield, std::allocator<int> > >, 
> cds::opt::hash<map::StripedMapHdrTest::hash_int>, 
> cds::opt::less<map::StripedMapHdrTest::less>, 
> cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul> 
> >}]'
>
> ../tests/test-hdr/map/hdr_striped_map.h:287:13: required from 'void 
> map::StripedMapHdrTest::test_int_with(Map&) [with Map = 
> cds::container::StripedMap<std::map<int, 
> map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>, 
> cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex, 
> cds::backoff::yield, std::allocator<int> > >, 
> cds::opt::hash<map::StripedMapHdrTest::hash_int>, 
> cds::opt::less<map::StripedMapHdrTest::less>, 
> cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul> 
> > >]'
>
> ../tests/test-hdr/map/hdr_striped_map.h:359:13: required from 'void 
> map::StripedMapHdrTest::test_striped_with(Map&) [with Map = 
> cds::container::StripedMap<std::map<int, 
> map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>, 
> cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex, 
> cds::backoff::yield, std::allocator<int> > >, 
> cds::opt::hash<map::StripedMapHdrTest::hash_int>, 
> cds::opt::less<map::StripedMapHdrTest::less>, 
> cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul> 
> > >]'
>
> ../tests/test-hdr/map/hdr_refinable_hashmap_map.cpp:78:32: required 
> from here
>
> ../cds/container/striped_map/std_map.h:134:138: error: 
> 'cds::intrusive::striped_set::adapt<std::map<int, 
> map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>, 
> cds::opt::type_traits<cds::container::details::make_striped_map<std::map<int, 
> map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>, 
> cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex, 
> cds::backoff::yield, std::allocator<int> > >, 
> cds::opt::hash<map::StripedMapHdrTest::hash_int>, 
> cds::opt::less<map::StripedMapHdrTest::less>, 
> cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul> 
> > >::options> >::container_type' has no member named 'emplace'
>
> . . .
>
> This is so since the #if condition failed: __GLIBCXX__ < 20130322. My 
> default g++ has __GLIBCXX__ set to 20130411. When I changed the 
> constant to 20130412, compilation become successful.
>
>

[Libcds-user] build of libcds-1.4.0 tests failed under Linux Mint 15 (Ubuntu 13.04) with g++ 4.7.3

[Алексей Е. <ave...@co...>]

I have tried to build the library/tests: “build.sh -p amd64 -o linux -b
64”. Libraries .so were built successfully, but tests weren’t



g++ -std=c++0x -c  -DNDEBUG -O3 -fno-strict-aliasing   -m64 -fPIC
-march=native    -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS
-D_FILE_OFFSET_BITS=64 -I.. -I../tests/test-hdr -I../tests
../tests/test-hdr/map/hdr_refinable_hashmap_map.cpp -o
../tests/test-hdr/map/hdr_refinable_hashmap_map.o

In file included from
../tests/test-hdr/map/hdr_refinable_hashmap_map.cpp:13:0:

../cds/container/striped_map/std_map.h: In instantiation of ‘bool
cds::intrusive::striped_set::adapt<std::map<_Key, _Tp, _Compare, _Alloc>,
Options ...>::adapted_container::emplace(Q&&, Args&& ...) [with Q = int;
Args = {}; Key = int; T = map::StripedMapHdrTest::value_type; Traits =
map::StripedMapHdrTest::less; Alloc = std::allocator<std::pair<const int,
map::StripedMapHdrTest::value_type> >; Options =
{cds::opt::type_traits<cds::container::details::make_striped_map<std::map<int,
map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>,
cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex,
cds::backoff::yield, std::allocator<int> > >,
cds::opt::hash<map::StripedMapHdrTest::hash_int>,
cds::opt::less<map::StripedMapHdrTest::less>,
cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul>
> >::options>}]’:

../cds/container/striped_map.h:728:17:   required from ‘bool
cds::container::StripedMap<Container, Options>::emplace(K&&, Args&& ...)
[with K = int; Args = {}; Container = std::map<int,
map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>; Options
=
{cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex,
cds::backoff::yield, std::allocator<int> > >,
cds::opt::hash<map::StripedMapHdrTest::hash_int>,
cds::opt::less<map::StripedMapHdrTest::less>,
cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul>
>}]’

../tests/test-hdr/map/hdr_striped_map.h:287:13:   required from ‘void
map::StripedMapHdrTest::test_int_with(Map&) [with Map =
cds::container::StripedMap<std::map<int,
map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>,
cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex,
cds::backoff::yield, std::allocator<int> > >,
cds::opt::hash<map::StripedMapHdrTest::hash_int>,
cds::opt::less<map::StripedMapHdrTest::less>,
cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul>
> >]’

../tests/test-hdr/map/hdr_striped_map.h:359:13:   required from ‘void
map::StripedMapHdrTest::test_striped_with(Map&) [with Map =
cds::container::StripedMap<std::map<int,
map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>,
cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex,
cds::backoff::yield, std::allocator<int> > >,
cds::opt::hash<map::StripedMapHdrTest::hash_int>,
cds::opt::less<map::StripedMapHdrTest::less>,
cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul>
> >]’

../tests/test-hdr/map/hdr_refinable_hashmap_map.cpp:78:32:   required from
here

../cds/container/striped_map/std_map.h:134:138: error:
‘cds::intrusive::striped_set::adapt<std::map<int,
map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>,
cds::opt::type_traits<cds::container::details::make_striped_map<std::map<int,
map::StripedMapHdrTest::value_type, map::StripedMapHdrTest::less>,
cds::opt::mutex_policy<cds::intrusive::striped_set::refinable<std::recursive_mutex,
cds::backoff::yield, std::allocator<int> > >,
cds::opt::hash<map::StripedMapHdrTest::hash_int>,
cds::opt::less<map::StripedMapHdrTest::less>,
cds::opt::resizing_policy<cds::intrusive::striped_set::load_factor_resizing<0ul>
> >::options> >::container_type’ has no member named ‘emplace’

. . .



This is so since the #if condition failed: __GLIBCXX__ < 20130322. My
default g++ has __GLIBCXX__ set to 20130411. When I changed the constant to
20130412, compilation become successful.

Re: [Libcds-user] Memory Management Methods

[Max K. <kh...@gm...>]

Hi Lucas,

The libcds uses different SMR techniques exactly. Hazard Pointer, 
Pass-the-Buck, HRC, - all of this is SMR. It is called "garbage 
collector" inside the library for short only. And yes, the main purpose 
of SMR is avoiding ABA problem.

About freelist. I thought a lot about incorporating a freelist into 
libcds but I reject this idea for the following reason:
approach based on classic freelist leads to unbounded memory 
consumption. The classic freelist (for example, that is used in tagged 
pointer technique) should be type-safe, so, for each type T a separate 
freelist should exist. The freelist may not be a non-static member of a 
lock-free container because any SMR deallocation can be deferred and can 
occur after container destruction. The lifetime of freelist must be 
greater than the lifetime of its container. If I declare freelist as a 
static member of highly templated container I can get linking problems 
in a complex project. So I try to avoid any static member in libcds 
templates.

Secondly, what is the freelist interface? We should pop an item from 
freelist and push it back when freeing.

Thus, the freelist property are:
1. It is almost-static object (to support deferred reclamation)
2. It has "pop" (allocate) and "push" (deallocate) methods.

Comparing these properties with std::allocator interface you'll see that 
freelist == allocator.
Result: you can use free-list concept in libcds. Just call the free-list 
as "allocator".

Best regards,
     Max Khiszinsky


On 06/28/2013 04:12 AM, Lucas Lersch wrote:
> I was re-reading the paper from Michael Maged, "High Performance 
> Dynamic Lock-Free Hash Tables
> and List-Based Sets" which seems to be used as the source for the 
> implementation of hash structures in libcds.
>
> The paper claims that the algorithm proposed is compatible with 
> different memory management methods. It also points that freelists and 
> safe memory reclamation are the only methods that are not extremely 
> inefficient, blocking or dependent on special system support. The 
> libcds seems to use a garbage collection memory management method 
> (probably to avoid the ABA problem). Is there a reason not to use 
> freelists or SMR? Is there an alternative? Is the garbage collection 
> environment so inefficient as it says?
>
> I would like some clarification in case I am getting it all wrong. 
> Thank you advance for the attention :)
>
>
> -- 
> Lucas Lersch
>
>
> _______________________________________________
> Libcds-user mailing list
> Lib...@li...
> https://lists.sourceforge.net/lists/listinfo/libcds-user

[Libcds-user] Memory Management Methods

[Lucas L. <luc...@gm...>]

I was re-reading the paper from Michael Maged, "High Performance Dynamic
Lock-Free Hash Tables
and List-Based Sets" which seems to be used as the source for the
implementation of hash structures in libcds.

The paper claims that the algorithm proposed is compatible with different
memory management methods. It also points that freelists and safe memory
reclamation are the only methods that are not extremely inefficient,
blocking or dependent on special system support. The libcds seems to use a
garbage collection memory management method (probably to avoid the ABA
problem). Is there a reason not to use freelists or SMR? Is there an
alternative? Is the garbage collection environment so inefficient as it
says?

I would like some clarification in case I am getting it all wrong. Thank
you advance for the attention :)


-- 
Lucas Lersch

[Libcds-user] libcds 1.4.0 is available for downloading

[Max K. <kh...@gm...>]

libcds 1.4.0 is a general release with following new features:

- Added: user-space RCU garbage collector (5 different implementations), see cds::urcu namespace
- Added: RCU-related set/map container specializations
- Added: Skip-list specialization for cds::gc::nogc (undeletable skip-list)
- For set/map classes: find_with and erase_with member functions have been added. These functions allow to use different predicates for searching.
- Added: threading model based on C++11 thread_local keyword (CDS_THREADING_CXX11). At present, only gcc 4.8 supports such model.
- Fixed: bug #11 "ABA bug in libcds 1.3.1 cds/intrusive/msqueue.h" Thanks to Jelle van den Hooff.
- Added support for GCC 4.8


Download new version from:http://sourceforge.net/projects/libcds/files/cds-1.4.0/  <http://sourceforge.net/projects/libcds/files/cds-1.3.1/>


   BR
      Max Khiszinsky

Re: [Libcds-user] Help with skip lists

[Max K. <kh...@gm...>]

Hi,

You can pass any extra data into SkipListMap::ensure using a functor and 
boost::ref (or cds::ref).
For example:

struct myUpdateFunctor {
     anytype    myExtraData ;

void operator()( bool bNew, cds::container::SkipListMap<...>::value_type 
<imap://khizmax%40gmail%2E...@im...:993/fetch%3EUID%3E/%5BGmail%5D/%26BB4EQgQ%2CBEAEMAQyBDsENQQ9BD0ESwQ1-%3E467?part=1.2.2&filename=classcds_1_1container_1_1_split_list_map.html>& 
item )
     {
         // Here you may use myExtraData to update item
     }
};

cds::container::SkipListMap<...> myMap ;
myUpdateFunctor myFunc ;
myFunc.myExtraData = ... ;
myMap.ensure( key, cds::ref( myFunc )) ;


cds::ref is used to pass myFunc by reference.

If your compiler supports C++11 you can use a lambda function instead of 
myUpdateFunctor object.

Note that SkipListMap does not guarantee atomic update of map items, it 
guarantees atomic update of map only.
Atomic modification on item level you should provide yourself. libcds 
only guarantees that item passed will not be deleted by any other thread 
while you are changing the item.

/> By the way, is there a plan to implement a gc::nogc version of 
SkipLists (no delete support is ok) ? Can I use the current one without 
garbage collection and not doing any deletes?//
/
SkipList<cds::gc::nogc> will be ready in the next release. However, you 
may use current GC-based implementation freely.
Just nogc-based implementation is more lightweight and has different 
interface closer to traditional programming like std.

Best regards,
     Max

On 03/06/2013 02:58 PM, Vaivaswatha N wrote:
> Hi,
>
> I'm trying to use the SkipListMap provided by libcds. My goal is to be 
> able to update a value atomically when the key is already present. 
> (I'm trying to implement a sparse bit vector on top of the SkipListMap 
> and hence will need to atomically set bits)
>
> When inserting a key/value paper, if the key is already present, the 
> SkipListMap interface "insert()"  will call a user-provided functor if 
> the item is already present. However, the signature of the functor is 
> such that it doesn't allow me to pass any other external data.
> So I'm restricted to update the value atomically by only knowing the 
> current value (without any other input).
>
> On the other hand, if I use LazyKVList or MichaelKVList, I can do this 
> by calling "ensure()" which will return an iterator. I can use the 
> iterator to atomically update my value.
>
> I'm interested to know if there is anyway to update values atomically 
> when the key is present (for SkipListMap).
>
> By the way, is there a plan to implement a gc::nogc version of 
> SkipLists (no delete support is ok) ? Can I use the current one 
> without garbage collection and not doing any deletes?
>
> Thanks a lot,
>
> -- 
>
> - Vaivaswatha

[Libcds-user] Help with skip lists

[Vaivaswatha N <vai...@gm...>]

Hi,

I'm trying to use the SkipListMap provided by libcds. My goal is to be able
to update a value atomically when the key is already present. (I'm trying
to implement a sparse bit vector on top of the SkipListMap and hence will
need to atomically set bits)

When inserting a key/value paper, if the key is already present, the
SkipListMap interface "insert()"  will call a user-provided functor if the
item is already present. However, the signature of the functor is such that
it doesn't allow me to pass any other external data.
So I'm restricted to update the value atomically by only knowing the
current value (without any other input).

On the other hand, if I use LazyKVList or MichaelKVList, I can do this by
calling "ensure()" which will return an iterator. I can use the iterator to
atomically update my value.

I'm interested to know if there is anyway to update values atomically when
the key is present (for SkipListMap).

By the way, is there a plan to implement a gc::nogc version of SkipLists
(no delete support is ok) ? Can I use the current one without garbage
collection and not doing any deletes?

Thanks a lot,

-- 

- Vaivaswatha

Re: [Libcds-user] Retrieve value with MichaelHashMap

[Max K. <kh...@gm...>]

Suppose, your container maps int to struct Foo:

struct Foo {
     my_rw_lock    lock   ;    //  access lock of some r/w type
     std::string       str     ;
};

typedef cds::container::MichaelHashMap< ... > map_type ;

map_type myMap ;
...

How to apply functor:

struct my_func {
     std::string strFound ;
     void operator()( map_type::value_type& val )
     {
         val.lock.lock_read()    ;
         strFound = val.str ;
         val.lock.unlock_read() ;
     }
};

my_func f ;
if ( myMap.find( 5, cds::ref(f)) ) {
     std::cout << "Value for 5 = " << f.strFound ;
}
else
     std::cout << "Not found" ;

In this code cds::ref (or boost::ref) is needed for passing functor by 
reference
since the functor contains data.

or, if your compiler supports C++11 lambda:

std::string strFound ;
if ( myMap.find( 5, [&strFound]( map_type::value_type& val) {
         val.lock.lock_read()   ;
         strFound = val.str     ;
         val.lock.unlock_read() ;
    } ) )
{
     std::cout << "Value for 5 = " << f.strFound ;
}
else
     std::cout << "Not found" ;

BR
     Max Khiszinsky

On 01/30/2013 05:26 PM, Lucas Lersch wrote:
> I am using MichaelHashMap following the example in the documentation 
> (http://libcds.sourceforge.net/doc/cds-api/classcds_1_1container_1_1_michael_hash_map.html#details). 
> I see I can pass a functor as argument to the find() method to 
> manipulate the <key,value> pair found. My problem is that I am having 
> problems to define such functor and to pass it as argument to the 
> find() method.
>
> Can someone provide me a simple example on how to retrieve a value 
> from the MichaelHashMap from a key, following the existing example in 
> the documentation?
>
> Thank you for the attention. :)
>
> -- 
> Lucas Lersch
>
>
> ------------------------------------------------------------------------------
> Everyone hates slow websites. So do we.
> Make your web apps faster with AppDynamics
> Download AppDynamics Lite for free today:
> http://p.sf.net/sfu/appdyn_d2d_jan
>
>
> _______________________________________________
> Libcds-user mailing list
> Lib...@li...
> https://lists.sourceforge.net/lists/listinfo/libcds-user

[Libcds-user] Retrieve value with MichaelHashMap

[Lucas L. <luc...@gm...>]

I am using MichaelHashMap following the example in the documentation (
http://libcds.sourceforge.net/doc/cds-api/classcds_1_1container_1_1_michael_hash_map.html#details).
I see I can pass a functor as argument to the find() method to manipulate
the <key,value> pair found. My problem is that I am having problems to
define such functor and to pass it as argument to the find() method.

Can someone provide me a simple example on how to retrieve a value from the
MichaelHashMap from a key, following the existing example in the
documentation?

Thank you for the attention. :)

-- 
Lucas Lersch

[Libcds-user] libcds 1.3.1 is available for downloading

[khizmax <kh...@gm...>]

libcds 1.3.1 is a maintenance release that fixed libcds building with 
boost versions before 1.48. Thanks Lucas Larsch who points me to this 
problem.

Download new version from: 
http://sourceforge.net/projects/libcds/files/cds-1.3.1/

Thanks for your interest for my library
  BR
     Max Khiszinsky

[Libcds-user] Problems to build

[Lucas L. <luc...@gm...>]

I am trying to build the lib and I get some errors. Some information:

uname -a
Linux ubuntu 2.6.32-45-generic #102-Ubuntu SMP Wed Jan 2 22:38:04 UTC 2013
x86_64 GNU/Linux

*Build:*
sh build.sh --clean -c gcc -x g++ -p amd64 -o linux -b 64 --with-boost
/usr/include --amd64-use-128bit

*First Error:*
In file included from
../tests/test-hdr/map/hdr_intrusive_michael_set_hrc.cpp:12:
../tests/test-hdr/map/hdr_intrusive_set.h: In member function ‘void
map::IntrusiveHashSetHdrTest::test_skiplist()’:
../tests/test-hdr/map/hdr_intrusive_set.h:629: error: ‘random_shuffle’ is
not a member of ‘std’
make: *** [../tests/test-hdr/map/hdr_intrusive_michael_set_hrc.o] Error 1

I added #include <algorithm> to the hdr_intrusive_set.h file and then I get
a different error.

*Second Error:*
../tests/test-hdr/map/hdr_intrusive_refinable_hashset_list.cpp:177:
instantiated from here
../cds/intrusive/striped_set.h:382: error: ‘class
boost::intrusive::list<map::IntrusiveStripedSetHdrTest::member_item<boost::intrusive::list_member_hook<>
>,
boost::intrusive::member_hook<map::IntrusiveStripedSetHdrTest::member_item<boost::intrusive::list_member_hook<>
>, boost::intrusive::list_member_hook<>,
&map::IntrusiveStripedSetHdrTest::member_item<boost::intrusive::list_member_hook<>
>::hMember> >’ has no member named ‘find’
make: *** [../tests/test-hdr/map/hdr_intrusive_refinable_hashset_list.o]
Error 1


I looked for the documentation of boost::intrusive::list(
http://www.boost.org/doc/libs/1_52_0/doc/html/boost/intrusive/list.html)
and indeed there is no find() member. Am I missing something?

Thank you advance.

-- 
Lucas Lersch

[Libcds-user] libcds 1.3.0 is available

[khizmax <kh...@gm...>]

New version libcsd 1.3.0 is available for download

New features:

1. New: StripedSet, StripedMap - hash set and hash map implementation 
based on fine-grained lock-striping technique

2. New: CuckooSet, CuckooMap - implementation of cuckoo hashing 
algorithm based on fine-grained lock-striping technique

3. New: SkipListSet, SkipListMap - implementation of lock-free skip list

4. New: template <typename... Args> emplace(Args&&... args) member 
function for all containers in cds::container namespace. This function 
is available  only if the compiler supports new C++11 features - 
variadic templates and move semantics.

5. Changed: lambda functions are used internally instead of wrapping 
functors. If the compiler does not support C++11 lambdas the old-style 
wrapping functors are used.

6. Changed: test projects has been splitted for optimizing compile time.

7. Breaking change: class cds::lock::Auto has been renamed to 
cds::lock::scoped_lock, class cds::lock::AutoUnlock has been removed

8. Support for MinGW has been added (tested with TDM-GCC 64bit, gcc 4.7)

Best regards
     Max Khiszinsky, libcds developer

[Libcds-user] libcds 1.2.0 is available

[khizmax <kh...@gm...>]

libcds 1.1.0 is available for downloading, visit http://sourceforge.net/projects/libcds/files/.
The following features are added:

MichaelDeque - deque lock-free algo discovered by Maged Michael

BasketQueue - Michael's queue modification discovered by Nir Shavit et al.

Support of Clang 3.0, 3.1 compiler for amd64, x86 (tested on Linux with boost 1.49)

Bugs fixed:
Fixed: solving problem of 8-byte atomic data alignment on 32-bit platforms

Fixed bug 3536393: OptimisticQueue core dump

[Libcds-user] libcds 1.1.0 is available

[khizmax <kh...@gm...>]

libcds 1.1.0 is available for downloading. The following features are 
added:

1. Added: C++11 atomic operations support. The library has been 
rewritten for using std::atomic class and operations proposed in C++11 
Standard. If the compiler does not support the standard <atomic> 
library, own partial implementation declared in cds/cxx11_atomic.h is 
used. cxx11_atomic.h contains implementation for lock-free part of C++11 
<atomic> header needed for libcds.

2. Added: support for C++11 feature (if applicable): - inline namespace 
(for GCC 4.4+) - function =default and =delete specifiers (for GCC 4.4+)

3. Changed: the main reclamation cycle ("liberate" function) of 
cds::gc::PTB memory reclamation schema has been optimized. Previous 
implementation could lead to unbounded memory consumption under high 
contention.

4. Changed: the internal structure of cds::intrusive::OptimisticQueue is 
greatly simplified. The interface of the class is slightly changed.

5. Fixed: some problem with cds::gc::HRC memory reclamation schema that 
could be the cause of occasional program crash.

6. Fixed: an error in node reclamation algo in queue implementation 
(MSQueue, MoirQueue, OptimisticQueue). As an result of the error, some 
items could be lost with memory leaks.

7. Changed: cds::concept namespace and its content has been removed

  8. Added support for Microsoft Visual C++ 11 Beta

9. Added support for GCC 4.7

[Libcds-user] Scalability micro-conference topic proposals (LPC2012)

[Mathieu D. <mat...@ef...>]

Hi,

We are organizing a micro-conference on scaling both upwards (many
cores) and downwards (low footprint, energy efficiency) that targets
all layers of the software stack. Our intent is to bring together
application, libraries and kernel developers to discuss the scalability
issues they currently face, and get exposure for the ongoing work on
scalability infrastructure.

Suggestions of topics are welcome. If you would like to present, please
let us know: we have lightnening-talk slots and a few 30 minutes slots
available. Presentations should be oriented towards stimulating
discussion over currently faced scalability problems and/or work in
progress in the area of scalability.

The micro-conference will be held between August 29-31, at LinuxCon
North America 2012, in San Diego.

   http://www.linuxplumbersconf.org/2012/

The Scaling Micro-Conference page is available at:

   http://wiki.linuxplumbersconf.org/2012:scaling

Best Regards,

Mathieu Desnoyers & Paul E. McKenney

-- 
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

[Libcds-user] any chance cds will be ported to os/x?

[david x c. <dx...@po...>]

any chance cds will be ported to os/x?  I tried -o linux, but of course that didn't work.  it is easy enough to build gcc-4.6.2 on snow leopard, so compiler support isn't an issue.

thx
dxc

[Libcds-user] libcds 1.0.0 is available

[khizmax <kh...@gm...>]

     This version is completely rewritten to support intrusive version 
of lock-free containers
     and more lightweight garbage collectors interface.
     The class hierarchy and interfaces have been completely 
reimplemented from scratch.

     1. Added: intrusive containers. Many lock-free containers in libcds 
have the intrusive
        counterparts. The library is fully refactored to support 
intrusive containers.
        Class hierarchy is changed: almost all non-intrusive container 
classes are based
        on their intrusive versions.
        Two new namespace is added:
         cds::intrusive - for intrusive containers
         cds::container - for non-intrusive containers
        Namespaces by container type (cds::queue, cds::map and so on) 
have been removed.

     2. Added: New option-based approach is used for class declaration 
instead
        old traits-based one. This approach allows to declare template 
arguments
        in position-independent manner that is very useful for complex 
template declarations.
        Option-based declarations use C++0x variadic templates if 
compiler supports it (GCC),
        otherwise (MS VC) an emulation is used.

     3. Changed: garbage collectors interface is generalized. 
cds::gc::GC (where GC is
        one of HP, HRC, PTB) classes has been added.

     4. Removed: tagged pointer GC. This GC
        - unsafe for complex data structure
        - x86-specific since it requires double-width CAS primitive
        - memory-consuming since it requires separate free-list for each 
type stored in the containers

     5. Default threading model is changed (see doc for cds::threading 
namespace):
        - for Windows and MSVC++, CDS_THREADING_WIN_TLS is the default now
        - for *nix and GCC, CDS_THREADING_PTHREAD is the default now

     6. Added GCC 4.6 support (constexpr)

     7. Added Microsoft Visual Studio 2010 (vc10) solution

[Libcds-user] CDS version 0.7.2 is available for downloading

[khizmax <kh...@gm...>]

This is bug-fix release.

     1. [Bug 3157201] Added implementation of threading manager based on 
Windows TLS API, see
        cds::threading::wintls::Manager. Added CDS_THREADING_WIN_TLS 
macro. See docs for
        cds::threading namespace for details.
     2. Fixed bug in cds::threading::pthread::Manager: ptb_gc has not 
been initialized properly.
     3. New function
             template <typename T, typename FUNC>
             bool erase( const key_type& key, T& dest, FUNC func ) ;
        has been added to all map classes.
     4. New function
             template <typename T, typename FUNC>
             bool insert( const key_type& key, T& val, FUNC func ) ;
        has been added to all map classes.
     5. Added new argument "bNew" to functor "func" of map's "ensure" 
member function:
             void func( VALUE& itemValue, const VALUE& val, bool bNew ) ;
         bNew = true if new item has been added
         bNew = false if key is found
     6. Fixed bug in cds::map::SplitOrderedList: LSB of dummy node's 
hash should be zero
     7. Changed: thread liveliness checking on *nix has been changed to 
pthread_kill(id, 0).
     8. Fixed: in map template member functions the functor may be 
passed by value
        or by reference; use boost::ref( yourFunctor ) to pass your 
functor by reference
     9. Fixed: cds::gc::tagged GC and all classes based on this GC has 
been rewritten
        to solve stability problems.

[Libcds-user] CDS version 0.7.2 is available for downloading

[khizmax <kh...@gm...>]

This is bug-fix release.

     1. [Bug 3157201] Added implementation of threading manager based on 
Windows TLS API, see
        cds::threading::wintls::Manager. Added CDS_THREADING_WIN_TLS 
macro. See docs for
        cds::threading namespace for details.
     2. Fixed bug in cds::threading::pthread::Manager: ptb_gc has not 
been initialized properly.
     3. New function
             template <typename T, typename FUNC>
             bool erase( const key_type& key, T& dest, FUNC func ) ;
        has been added to all map classes.
     4. New function
             template <typename T, typename FUNC>
             bool insert( const key_type& key, T& val, FUNC func ) ;
        has been added to all map classes.
     5. Added new argument "bNew" to functor "func" of map's "ensure" 
member function:
             void func( VALUE& itemValue, const VALUE& val, bool bNew ) ;
         bNew = true if new item has been added
         bNew = false if key is found
     6. Fixed bug in cds::map::SplitOrderedList: LSB of dummy node's 
hash should be zero
     7. Changed: thread liveliness checking on *nix has been changed to 
pthread_kill(id, 0).
     8. Fixed: in map template member functions the functor may be 
passed by value
        or by reference; use boost::ref( yourFunctor ) to pass your 
functor by reference
     9. Fixed: cds::gc::tagged GC and all classes based on this GC has 
been rewritten
        to solve stability problems.

[Libcds-user] CDS version 0.7.1 is available for downloading

[khizmax <kh...@gm...>]

This is bug-fix release
Changes:

     1. [Bug 3130852] cds::queue::TZCyclicQueue::empty() has been corrected
     2. [Bug 3128161] It seems, GCC 4.4 has a bug in __thread on x86 and 
x86_64. New "threading model"
        CDS_THREADING_AUTODETECT has been added. See docs of 
cds::threading namespace for details
     3. Fixed errors in the "Pass-the-Buck" garbage collector (namespace 
cds::gc::ptb)
     4. [Bug 3128148] The code is aligned with the C++ standard (minor 
violations has been removed)
     5. [Bug 3141654] missing break statement for atomic store - fixed
     6. Added in-place scan strategy to cds::gc::hzp::GarbageCollector. 
The strategy does not allocate any memory.
     7. Fixed bugs in HRC and tagged GC

[Libcds-user] CDS version 0.7.0 is available for downloading

[khizmax <kh...@gm...>]

Changes:
     1. Preliminary support for "Pass The Buck" memory manager is added. 
See cds::gc::ptb namespace.
     2. Many part of library is rewritten to generalize the usage of 
various GCs
     3. The new class cds::details::aligned_allocator has been added for 
allocating aligned memory
        blocks. It is useful for Tagged Pointer memory reclamation 
schema (cds::gc::tagged_gc).
     4. [Break change] New argument has been added to the member 
functions "ensure" and "find"
        for ordered list and map classes
     5. New member function "emplace" has been added to ordered list and 
map classes. This member function
        allows change the value (or a part of it) of list/map item.
     6. The internal structure of class cds::map::MichaelHashMap is 
completely refactored to support
        cds::gc::no_gc correctly
     7. The classes RecursiveSpinT, RecursiveSpin32, RecursiveSpin64, 
and RecursiveSpin from cds::lock
        namespace have been renamed to ReentrantSpinT, ReentrantSpin32, 
ReentrantSpin64, and ReentrantSpin
        respectively
     8. Compiler support: GCC version below 4.3.0 is not supported
     9. Fixed memory leak in cds::map::SplitOrderedList
    10. Added compiler barrier to spin-lock release primitive for x86 
and amd64
    11. Makefile script is changed to resolve the problem when an user 
calls 'make clean' directly.
        Thanks to Tamas Lengyel to point me to this bug.
    12. The file dictionary.txt is exluded from distributive. This file 
is used for testing purposes only.

Re: [Libcds-user] make clean oops

[khizmax <kh...@gm...>]

 > after accidentally doing a sudo make clean from the build folder I 
had half of my / removed .. like /boot..

Hi, Tamas

Oops... Direct 'make clean' calling is dangerous. Instead, build.sh should be called.
I'll fix Makefile to prevent this fatal result in the next release. Sorry.

 > Before that the build failed not finding boost_thread-static on 
ubuntu. I had libboost-dev installed, apparently in shared library > 
format. Does that make a difference?

'boost_thread-static' is my name of thread lib. You may patch Makefile: 
find 'boost_thread-static' and replace it with your name ( 
'boost_thread' usually)

[Libcds-user] make clean oops

[Tamas L. <tam...@gm...>]

Hi all,
after accidentally doing a sudo make clean from the build folder I had half
of my / removed .. like /boot..

Before that the build failed not finding boost_thread-static on ubuntu. I
had libboost-dev installed, apparently in shared library format. Does that
make a difference?

Tamas