Smieciuch Garbage Collector / News: Recent posts

Smieciuch++ is a little nice portable precise garbage collection library for standard C++. Smieciuch defines smart pointer classes gc_ptr, const_gc_ptr, gc_arr & const_gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer, singular const object pointer, array pointer & const array pointer) but you don't have to explicitly free them, and unlike various similar smart pointer solutions Smieciuch's gc_ptr will have no problem with circular referencing. And it's typically somewhat faster than typical reference counting solutions - this release was measured against boost::shared_ptr and benchmarked around 10% better on pointer&allocation intensive code. ... read more

Smieciuch++ is a little nice portable precise garbage collection library for standard C++. Smieciuch defines smart pointer classes gc_ptr, const_gc_ptr, gc_arr & const_gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer, singular const object pointer, array pointer & const array pointer) but you don't have to explicitly free them, and unlike various similar smart pointer solutions Smieciuch's gc_ptr will have no problem with circular referencing. And it's typically somewhat faster than typical reference counting solutions - this release was measured against boost::shared_ptr and benchmarked around 10% better on pointer&allocation intensive code. ... read more

Smieciuch++ is a little nice portable precise garbage collection library for standard C++. Smieciuch defines smart pointer classes gc_ptr, const_gc_ptr, gc_arr & const_gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer, singular const object pointer, array pointer & const array pointer) but you don't have to explicitly free them, and unlike various similar smart pointer solutions Smieciuch's gc_ptr will have no problem with circular referencing. And it's typically somewhat faster than typical reference counting solutions - this release was measured against boost::shared_ptr and benchmarked around 10% better on pointer&allocation intensive code.... read more

Smieciuch++ is a little nice portable precise garbage collection library for C++. Smieciuch defines smart pointer classes gc_ptr, const_gc_ptr, gc_arr & const_gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer, singular const object pointer, array pointer & const array pointer) but you don't have to explicitly free them (and unlike various similar smart pointer solutions Smieciuch's gc_ptr will have no problem with circular referencing).... read more

Smieciuch++ is a little nice portable precise garbage collection library for C++. Smieciuch defines smart pointer classes gc_ptr, const_gc_ptr, gc_arr & const_gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer, singular const object pointer, array pointer & const array pointer) but you don't have to explicitly free them (and unlike similar shared_ptr from boost library Smieciuch's gc_ptr will have no problem with circular referencing). ... read more

Smieciuch++ is a little nice portable precise garbage collection library for C++. Smieciuch defines smart pointer classes gc_ptr, const_gc_ptr, gc_arr & const_gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer, singular const object pointer, array pointer & const array pointer) but you don't have to explicitly free them (and unlike similar shared_ptr from boost library Smieciuch's gc_ptr will have no problem with circular referencing). ... read more

Smieciuch++ is a little nice portable precise garbage collection library for C++. Smieciuch defines smart pointer classes gc_ptr & gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer & array pointer) but you don't have to explicitly free them (and unlike similar shared_ptr from boost library Smieciuch's gc_ptr will have no problem with circular referencing). ... read more

Smieciuch++ is a little nice portable precise garbage collection library for C++. Smieciuch defines smart pointer classes gc_ptr & gc_arr which behave like normal plain C/C++ pointers (respectively singular object pointer & array pointer) but you don't have to explicitly free them (and unlike similar shared_ptr from boost library Smieciuch's gc_ptr will have no problem with circular referencing).... read more

Smieciuch++ is a portable precise garbage collector written in nearly pure C++. It implements a smartpointer class template which behaves much like plain pointer, but allows to forget about delete without causing memory leak, as library itself will find & free all the unreachable objects.

Word 'precise' means that library exactly knows what is an unreachable object as well as which objects are unreachable and does not need to guess that (as so called conservative collector must do) and will free all such objects (again unlike conservative collector, which might leak from time to time).... read more

Smieciuch++ is a portable precise garbage collector written in nearly pure C++. It implements a smartpointer class template which is behaves much like plain pointer, but allows to forget about delete without causing memory, as library will find & free all the unreachable objects.

Word 'precise' means that library exactly knows what is an unreachable object and does not need to guess (as so called conservative collector does) and will free all such objects (again unlike conservative collector, which might leak from time to time).... read more

So here it comes! Even faster and even better, at the very half way to 1.0 stage! :)

Smieciuch++ is a very portable (allmost fully C++ standard compliant) precise garbage collection library. It's real GC, not yeat another variation of reference counting, so it's fully resistant to reference cycles, and free of other drawbacks of most reference counting impelmentations. Precise means it's able to find all it's managed pointers, not only guess what is not a managed pointer and treat all suspects as they really were such pointers (as conservative collectors like the famous Hans Boehms collector do), so it won't mess some nonpointer object only looking like pointer with its smart pointer class objects and in effect it won't leak (all conservative collectors do leak from time to time).
It's not only pure solution, it's also very simple and lightweight (library is just 1520 nonempty lines of C++ code -- headers are included). And last but not least it's reasonably fast as well (testing indicates it's just 21% slower than explicit management approach -- i.e. using explicit delete -- so it's probably an acceptable price for leakproofing and simplifying as well shortening your source).... read more

Smieiciuh++ is a precise & quite efficient garbage collector written in nearly pure C++. This new version is (based on example test code) only 21% slower than clasical explicit memory management using new&delete pairs.
This RC version employs new set of performance & memory usage optimisations, and fixes few bugs.
When the code is tested on the other supported configutations (not only GCC 3.2 on x86 Linux) it'll become a full 0.5.0 release.... read more

New version of precise, pure standard C++ Garbage Collector is out. Cleaner and even faster.
The code is checked to work on x86 and Alpha (both as 32 and 64bit), on Linux, Windows, Tru64 Unix and OpenVMS. But as it's pure C++ it should work on any decent and ISO compliant not multithreaded C++ runtime environment. Threading is planed as an option for the future, but now is not supported.

Enjoy!

Last week I got confirmatiopn, that Smieciuch++ 0.4.0 compiles and works (basic test actually) on Linux running on PowerPC chips. This is beats up the confidence, that its portable across platrofms for which there is a standards compliant C++ compiler & runtime.

Smieciciuch++ 0.4.0 is out. Notice the change of name -- since now Smieciuch is splitted into two independent libraries: Smieciuch++ and Smieciuch C.
Though Smieciuch C development is now suspended.

Smieciuch++ mark a complete cjange of the approach, allowing for full C++ standard conformance and 30% better performance.

Enjoy completely new Smieciuch

New version of Smieciuch Garbage Collector (neraly
precise in plain C, and fully precise for C++) is out.
This time the main enhancement is full support for
objects of multiply inherited classes.

Enjoy

PS. I'm eagerly awaiting some users feedback!

Sebastian

This next minor upgrade to Smieciuch Garbage Collector
(Precise on C++ and neraly-precise on C) gets rid of yet
another bug and brings Makefile.msvc -- allowing automated
building on MSVC on Win32 x86 platform.

Enjoy!

New territory expanding (and bufix, too) version of Smieciuch Garbage Collector is out!
Also check out project homepage of this precise for C++ and nearly-precise for C garbage collector.

This minor version update of fully precise C++ Garbage Collector and neraly precise C Garbage Collector library fixes one important bug and few minor ones and this time allows for building with both GCC + Linux and MSVC (6.0) + Windows.

Volunteers to try and test the thing on more & more platforms are welcome!

New veriosn of my precise C++ garbage collector (and
neraly-precise C collector) is out. Tried under x86 Linux
with GCC 3.2. Should work also with 2.96 and so. Also
effrot was made to make it compatible with MSVC (C
version works for some time, C++ is untested but
should be at worst close).

This stuff now requires much more testing -- if you want
to contribute -- you're welcome!

PS.
This time all the files should be present in the distribution.

Previus versions were fatally ridden by hordes of bugs all
the way. This version is somewhat less buggy for sure. For
now it was only tested on GCC, and C++ code is allmost
guaranteed not to build under for example is MSVC.
C version should be better in that regard.

Enjoy!

So here it comes. Smieciuch 0.3.0 is first version with C++ stuff (smart pointer class template) in. And in C++ it's not just allmost (or nearly) precise collector, it's fully precise one!

Get the new version, tested on 5 different compilers under 4 different platforms (two of them being non x86, one sporting 64bit address space).
Some importnat bugfixes commited, as well as a bit improved tester (was able to catch one subtle error with lack of volatile in right place causeing optimised GCC 3.2 code to coredump).

Now I've non-zero confidence that this code is useable.

Enjoy.

Verion 0.1.1 with some buffixes and significantly better commeted code is available for some time already (if you didn't noticed)

First public release of Smieciuch, published under version 0.1.0-1, is out. Check release notes for more info.