differential reference counting...

[Chris M. Thomasson]

Dmitry Vyukov, my good friend way back on comp.programming.threads wrote
up a pretty good and to the point description on the overall technique:

http://www.1024cores.net/home/lock-free-algorithms/object-life-time-management/differential-reference-counting

Now, I used to have a nice example program up under my comcast account
way back in 2003-2007, however comcast deleted all of their web access.
I think I lost it forever. Need to try the way back machine. Dmitry
kindly included a link to my old stuff here:

http://www.1024cores.net/home/lock-free-algorithms/links
(search the text of the page for my last name)

The link was to: http://webpages.charter.net/appcore/

However, its deader than dead now. Dmitry knew it was
special:
https://groups.google.com/g/comp.programming.threads/c/ghfE_KPh_LU/m/Mb6vnbVjFNwJ

He references my work, dead links:

http://webpages.charter.net/appcore/misc/pc_sample_c.html

Now, I need to either find it on the way back machine, or recreate it
from scratch. Iirc, it used over alignment to store a little reference
count in the proxy collector anchor.

I am going to reimplement my differential reference counting thing in
this thread using C++17.

Dmitry mentions my name again here:

http://www.1024cores.net/home/lock-free-algorithms/object-life-time-management/differential-reference-counting/implementation

this is going to make my mind explode. This was so long ago! However, I
think I can create it from scratch using pure C++17 without going to the
way back machine...

However... I thank Bonita for making me want to do this.

[Chris M. Thomasson]

On 1/27/2021 9:23 PM, Chris M. Thomasson wrote:
> Dmitry Vyukov, my good friend way back on comp.programming.threads wrote
> up a pretty good and to the point description on the overall technique:
>
> http://www.1024cores.net/home/lock-free-algorithms/object-life-time-management/differential-reference-counting
>
>
> Now, I used to have a nice example program up under my comcast account
> way back in 2003-2007, however comcast deleted all of their web access.
> I think I lost it forever. Need to try the way back machine. Dmitry
> kindly included a link to my old stuff here:
>
> http://www.1024cores.net/home/lock-free-algorithms/links
> (search the text of the page for my last name)

[...]

> this is going to make my mind explode. This was so long ago! However, I
> think I can create it from scratch using pure C++17 without going to the
> way back machine...
>
> However... I thank Bonita for making me want to do this.

Humm... a First start would be to port the following proxy collector I
created to pure C++17. Here is a full implementation, but it uses Relacy
Race Detector:

https://groups.google.com/g/lock-free/c/X3fuuXknQF0/m/0VF_u-7shrsJ

code:

https://pastebin.com/raw/f71480694

This should be rather easy to port. However, I need to run it again in
Relacy, just for good ol' times... ;^)

[Chris M. Thomasson]

On 1/27/2021 9:23 PM, Chris M. Thomasson wrote:

> Dmitry Vyukov, my good friend way back on comp.programming.threads wrote
> up a pretty good and to the point description on the overall technique:
>
> http://www.1024cores.net/home/lock-free-algorithms/object-life-time-man

[...]

I ported one of my proxy collectors from Relacy to C++17, however the
impl code does not create any threads yet. This is a basic mock up.

https://pastebin.com/raw/p1E9WN5i

I will be showing how to use this code to create a poor mans RCU that
can beat read write locks.

Version -1, I am working on version 1 that will simulate a RCU like
scenario. Think of a dynamic lock-free stack, that requires no DWCAS,
and can allow reader threads to iterate through it as writer threads are
mutating it. A writer can defer a node for destruction, and when it
finally gets deleted, well, we are sure that no other thread is
accessing it. Just like RCU.

Code, can you get it compile on your end?

I am currently making sure everything is aligned and padded, and adding
in threads with a reader writer test.
_____________________________
#include <iostream>
#include <atomic>
#include <thread>
#include <cstdlib>
#include <cstdint>


// Some debug/sanity check things...
// Need to make this conditional in compilation with some macros
static std::atomic<unsigned long> g_debug_node_allocations(0);
static std::atomic<unsigned long> g_debug_node_deallocations(0);


// Need to align and pad data structures! To do...


struct ct_node
{
std::atomic<ct_node*> m_next;
ct_node* m_defer_next;

ct_node()
{
g_debug_node_allocations.fetch_add(1, std::memory_order_relaxed);
}

~ct_node()
{
g_debug_node_deallocations.fetch_add(1, std::memory_order_relaxed);
}
};




template<std::size_t T_defer_limit>
class ct_proxy
{
static void prv_destroy(ct_node* n)
{
while (n)
{
ct_node* next = n->m_defer_next;
delete n;
n = next;
}
}


public:
class collector
{
friend class ct_proxy;

private:
std::atomic<ct_node*> m_defer;
std::atomic<unsigned int> m_defer_count;
std::atomic<unsigned int> m_count;



public:
collector()
: m_defer(nullptr),
m_defer_count(0),
m_count(0)
{

}


~collector()
{
prv_destroy(m_defer.load(std::memory_order_relaxed));
}
};



private:
std::atomic<unsigned int> m_current;
std::atomic<bool> m_quiesce;
ct_node* m_defer;
collector m_collectors[2];



public:
ct_proxy()
: m_current(0),
m_quiesce(false),
m_defer(nullptr)
{

}

~ct_proxy()
{
prv_destroy(m_defer);
}

private:
void prv_quiesce_begin()
{
// Try to begin the quiescence process.
if (!m_quiesce.exchange(true, std::memory_order_acquire))
{
// advance the current collector and grab the old one.
unsigned int old =
m_current.load(std::memory_order_relaxed) & 0xFU;
old = m_current.exchange((old + 1) & 1,
std::memory_order_acq_rel);
collector& c = m_collectors[old & 0xFU];

// decode reference count.
//unsigned int refs = old & 0xFFFFFFF0U; HOLY SHIT!!!
long refs = old & 0xFFFFFFF0U;

// verify reference count and previous collector index.
// RL_ASSERT(!(refs & 0x10U) && (old & 0xFU) == (&c -
m_collectors));

// increment and generate an odd reference count.
if (c.m_count.fetch_add(refs + 0x10U,
std::memory_order_release) == (unsigned int)-refs)
{
// odd reference count and drop-to-zero condition detected!
prv_quiesce_complete(c);
}
}
}


void prv_quiesce_complete(collector& c)
{
// the collector `c' is now in a quiescent state! :^)
std::atomic_thread_fence(std::memory_order_acquire);

// maintain the back link and obtain "fresh" objects from
// this collection.
ct_node* n = m_defer;
m_defer = c.m_defer.load(std::memory_order_relaxed);
c.m_defer.store(0, std::memory_order_relaxed);

// verify and reset the reference count.
//RL_ASSERT(c.m_count.load(std::memory_order_relaxed) == 0x10U);
c.m_count.store(0, std::memory_order_relaxed);
c.m_defer_count.store(0, std::memory_order_relaxed);

// release the quiesce lock.
m_quiesce.store(false, std::memory_order_release);

// destroy nodes.
prv_destroy(n);
}


public:
collector& acquire()
{
// increment the master count _and_ obtain current collector.
unsigned int current =
m_current.fetch_add(0x20U, std::memory_order_acquire);

// decode the collector index.
return m_collectors[current & 0xFU];
}


void release(collector& c)
{
// decrement the collector.
unsigned int count =
c.m_count.fetch_sub(0x20U, std::memory_order_release);

// check for the completion of the quiescence process.
if ((count & 0xFFFFFFF0U) == 0x30U)
{
// odd reference count and drop-to-zero condition detected!
prv_quiesce_complete(c);
}
}


collector& sync(collector& c)
{
// check if the `c' is in the middle of a quiescence process.
if (c.m_count.load(std::memory_order_relaxed) & 0x10U)
{
// drop `c' and get the next collector.
release(c);

return acquire();
}

return c;
}


void collect()
{
prv_quiesce_begin();
}


void collect(collector& c, ct_node* n)
{
if (!n) return;

// link node into the defer list.
ct_node* prev = c.m_defer.exchange(n, std::memory_order_relaxed);
n->m_defer_next = prev;

// bump the defer count and begin quiescence process if over
// the limit.
unsigned int count =
c.m_defer_count.fetch_add(1, std::memory_order_relaxed) + 1;

if (count >= (T_defer_limit / 2))
{
prv_quiesce_begin();
}
}
};




// you're basic lock-free stack...
// well, minus ABA counter and DWCAS of course! ;^)
class ct_stack
{
std::atomic<ct_node*> m_head;



public:
ct_stack()
: m_head(nullptr)
{

}



public:
void push(ct_node* n)
{
ct_node* head = m_head.load(std::memory_order_relaxed);

do
{
n->m_next.store(head, std::memory_order_relaxed);
}

while (!m_head.compare_exchange_weak(
head,
n,
std::memory_order_release));
}


ct_node* flush()
{
return m_head.exchange(NULL, std::memory_order_acquire);
}


ct_node* get_head()
{
return m_head.load(std::memory_order_acquire);
}


ct_node* pop()
{
ct_node* head = m_head.load(std::memory_order_acquire);
ct_node* xchg;

do
{
if (!head) return NULL;

xchg = head->m_next.load(std::memory_order_relaxed);
}

while (!m_head.compare_exchange_weak(
head,
xchg,
std::memory_order_acquire));

return head;
}
};



int main()
{
std::cout << "Hello World!\n\n";
std::cout << "Chris M. Thom:assons Proxy Collector Port ver -1...
lol ;^D\n\n";

{
typedef ct_proxy<5> proxy;
proxy gc;

gc.collect();

{
proxy::collector& c = gc.acquire();

gc.collect(c, new ct_node);
gc.collect(c, new ct_node);

gc.collect();

gc.collect(c, new ct_node);
gc.collect(c, new ct_node);
gc.collect(c, new ct_node);

gc.release(c);
}

{
proxy::collector& c = gc.acquire();

gc.release(c);
}

{
proxy::collector& c = gc.acquire();

gc.collect(c, new ct_node);
gc.collect(c, new ct_node);
gc.collect();
gc.collect(c, new ct_node);
gc.collect();
gc.collect(c, new ct_node);
gc.collect(c, new ct_node);
gc.collect(c, new ct_node);
gc.release(c);
}

gc.collect();
gc.collect();
}

{
unsigned long node_allocations =
g_debug_node_allocations.load(std::memory_order_relaxed);
unsigned long node_deallocations =
g_debug_node_deallocations.load(std::memory_order_relaxed);

std::cout << "node_allocations = " << node_allocations << "\n";
std::cout << "node_deallocations = " << node_deallocations << "\n";

if (node_allocations != node_deallocations)
{
std::cout << "OH SHIT! NODE LEAK!!! SHIT! = " <<
node_allocations - node_deallocations << "\n\n";
}

}

return 0;
}

_____________________________

[Chris M. Thomasson]

On 1/28/2021 9:57 PM, Chris M. Thomasson wrote:
> On 1/27/2021 9:23 PM, Chris M. Thomasson wrote:
>> Dmitry Vyukov, my good friend way back on comp.programming.threads
>> wrote up a pretty good and to the point description on the overall
>> technique:
>>
>> http://www.1024cores.net/home/lock-free-algorithms/object-life-time-man
>
> [...]
>
> I ported one of my proxy collectors from Relacy to C++17, however the
> impl code does not create any threads yet. This is a basic mock up.
>
> https://pastebin.com/raw/p1E9WN5i
>
> I will be showing how to use this code to create a poor mans RCU that
> can beat read write locks.
>
> Version -1, I am working on version 1 that will simulate a RCU like
> scenario. Think of a dynamic lock-free stack, that requires no DWCAS,
> and can allow reader threads to iterate through it as writer threads are
> mutating it. A writer can defer a node for destruction, and when it
> finally gets deleted, well, we are sure that no other thread is
> accessing it. Just like RCU.
>
> Code, can you get it compile on your end?
>
> I am currently making sure everything is aligned and padded, and adding
> in threads with a reader writer test.
> _____________________________

[...]

>         {
>             proxy::collector& c = gc.acquire();
>
>             gc.collect(c, new ct_node);
>             gc.collect(c, new ct_node);
>
>             gc.collect();
>
>             gc.collect(c, new ct_node);
>             gc.collect(c, new ct_node);
>             gc.collect(c, new ct_node);
>
>             gc.release(c);
>         }

[...]
Ahhh.... Of course gc.acquire/release would definitely benefit from a
RAII helper class!

[Chris M. Thomasson]

On 1/27/2021 9:23 PM, Chris M. Thomasson wrote:

> Dmitry Vyukov, my good friend way back on comp.programming.threads wrote
> up a pretty good and to the point description on the overall technique:
>
> http://www.1024cores.net/home/lock-free-algorithms/object-life-time-management/differential-reference-counting

[...]

The original creator of PDR or PCOW deferred reclamation, I remember
this old post way back in 2005:

It was wonderful conversing with then, Joe Seigh, Peter Dimov, Alex T, ect:

https://groups.google.com/g/comp.programming.threads/c/PHY2mNpTfY8/m/Uqhc2SsFt_AJ


I got to converse with hyper smart people over on the now dead
comp.programming.threads. David Butenhof, the POSIX guru...

Its odd the Google cut off comp.lang.c. Check it out. Try to access
comp.lang.c using Google Groups. WOW! What a shit move. Fu%$#$@#$
$$GB%%^# Qubert ease right here.

[Michael S]

Sorry for hijacking, but google groups asks me to join in order to start a thread properly and right now I amnot in the mood of doing *anything* google asks me.

FYI, Google groups banned comp.lang.c. Banned completely, in a manner that provides no "read anyway" button or something of this sort.
IMHO, we should protest, including those of us that wouldn't touch google groupswith a ten-foot pole.

[Chris M. Thomasson]

Google did the same to its Google+. Those a-holes just destroyed it all,
the bathwater, the babies, all of it. Then they said we can download an
archive, but it was hyper buggy! Check this out:

https://www.googleplusdatalitigation.com

I actually lost some novel fractal algorithms on there! Anyway...

;^o


I have linked to many interesting posts using google groups into
comp.lang.c. Google has a fairly decent search into Usenet, so be it.
They are all banned now wrt comp.lang.c! Why destroy something just
because some bastard spammers exist? Pardon my French, but FUC@ Google
for this shi%. Let me curse in qbert ease, vent a bit...
!@$%^&^&%$%%GQ#$#@$@@. There. Take that Google! ;^)

Damn it all to hell. Whats next, banning sci.crypt? comp.lang.c++? Ahh,
Googles own code might not be able to ban comp.lang.c++ because when
they executed the command, the ++ was stripped off and they banned
comp.lang.c. WOW! They were sending user posts meant for comp.lang.c++
to comp.lang.c. Damn, what a total sad Joke!

;^/

[Jorgen Grahn]

[trimming the quote, adjusting the subject line, and reflowing the
text]

On Sat, 2021-01-30, Michael S wrote:
> Sorry for hijacking, but google groups asks me to join in order to
> start a thread properly and right now I amnot in the mood of doing
> *anything* google asks me.
>
> FYI, Google groups banned comp.lang.c. Banned completely, in a
> manner that provides no "read anyway" button or something of this
> sort. IMHO, we should protest, including those of us that wouldn't
> touch google groupswith a ten-foot pole.

Also see <https://lwn.net/Articles/827233/>, which seems to be from
when comp.lang.lisp got the same treatment back in July.

/Jorgen

--
// Jorgen Grahn <grahn@ Oo o. . .
\X/ snipabacken.se> O o .

[Öö Tiib]

On Sunday, 31 January 2021 at 10:17:20 UTC+2, Jorgen Grahn wrote:
> [trimming the quote, adjusting the subject line, and reflowing the
> text]
> On Sat, 2021-01-30, Michael S wrote:
> > Sorry for hijacking, but google groups asks me to join in order to
> > start a thread properly and right now I amnot in the mood of doing
> > *anything* google asks me.
> >
> > FYI, Google groups banned comp.lang.c. Banned completely, in a
> > manner that provides no "read anyway" button or something of this
> > sort. IMHO, we should protest, including those of us that wouldn't
> > touch google groupswith a ten-foot pole.
> Also see <https://lwn.net/Articles/827233/>, which seems to be from
> when comp.lang.lisp got the same treatment back in July.

Perhaps Google AI dislikes posts of that BASTARDO NAZI PEDOPHILO
ASSASSINO madman. Strange that it does not filter such easy to filter
crap instead of blocking the newsgroups where no one looks at such
nausea anyway.

[Rick C. Hodgin]

The world is changing. People are being taught unaware that there are
others in control of their lives. They must bow to the state and
businesses who will demand things of you or you can't buy or sell.

The truth is, this is all a precursor to the coming mark of the beast
system that will be in the 7-year tribulation. We're seeing the
groundwork being laid down right now.

I urge everyone to come to repentance in Jesus Christ. To ask
forgiveness for your sin and escape the coming calamity on Earth.

-----
Jesus is your creator. He made you and doesn't want to judge you for
the things you've done which are sin in His judgment. Instead, He
wants to forgive you. He wants to set you free from that judgment like
it never even happened.

We each have sin. That sin causes us to be facing a day of judgment
before God. What Jesus does is take away our sin. He lived on the
Earth 2,000 years ago for about 33.5 years. He was God in the flesh,
in a literal body like ours feeling all we feel, emotions, tiredness,
hunger, thirst, hearing music, singing, dancing, everything. But
unlike us He never sinned. This allowed Him to take on the weight of
sin for all who believe in Him, so that He would die with our sin and
we would be released from it.

Jesus came to save men's souls from death, and from being cast into the
eternal lake of fire. He came here in love, and He reaches out in love
and forgiveness no matter what you've done, or how far you've strayed.

He loves you with His whole heart, and He calls out to you through men
and women like me pointing you to Him, but He calls out to you first
and truly from that inner voice, the still small voice on the inside
that is His signature call. You know that voice. You know why He's
calling out to you (because He loves you and doesn't want to judge you,
but is longing with greatest longing to forgive you).

Put your faith and trust in Jesus today and ask Him to forgive your
sin. You'll feel the change the moment you do. You'll feel eternity
alive before you, and your future being secure.

In love and hope men and women like me post these messages so that men
and women like you will hear them and be set free, just as we were from
others who went before us calling out likewise.

There is forgiveness at the cross of Christ. Real forgiveness. A
fresh start. A new purpose in living.

Peace.

--
Rick C. Hodgin

[Chris M. Thomasson]

On 1/31/2021 12:17 AM, Jorgen Grahn wrote:
> [trimming the quote, adjusting the subject line, and reflowing the
> text]
>
> On Sat, 2021-01-30, Michael S wrote:
>> Sorry for hijacking, but google groups asks me to join in order to
>> start a thread properly and right now I amnot in the mood of doing
>> *anything* google asks me.
>>
>> FYI, Google groups banned comp.lang.c. Banned completely, in a
>> manner that provides no "read anyway" button or something of this
>> sort. IMHO, we should protest, including those of us that wouldn't
>> touch google groupswith a ten-foot pole.
>
> Also see <https://lwn.net/Articles/827233/>, which seems to be from
> when comp.lang.lisp got the same treatment back in July.
>

DAMN!

[Chris M. Thomasson]

On 1/27/2021 9:23 PM, Chris M. Thomasson wrote:

> Dmitry Vyukov, my good friend way back on comp.programming.threads wrote
> up a pretty good and to the point description on the overall technique:
>
> http://www.1024cores.net/home/lock-free-algorithms/object-life-time-management/differential-reference-counting

[...]

Hey now! I just got back in touch with Joe Seigh. The inventor of proxy
collection. Fun times are ahead! :^)

Almost done with a use case for my implementation of a proxy collector.

[Öö Tiib]

Seems that the idea that Google bans because of Skybuck Flying
nonsense is wrong. It is more likely some kind of all caps nonsense
generator written by pederasta pompinara italiano that seems to
post from Google's accounts.

[David Brown]

Both Skybuck and that weird Italian all-caps poster use google groups to
send their messages. Google should just do as many regular Usenet users
do - automatically kill any messages sent via google groups.

The all-caps Italian posts have been coming a few times per year for as
long as I can remember - why would that lead to a problem /now/ ?
Skybuck's Covid conspiracy theories and assorted insanity, on the other
hand, are precisely the kind of thing that gets people chucked off
twatter, facebook, and other social media at the moment. (At least
these have the wit to block the poster, not close off everyone who might
have unwillingly have seen the message).

(Yes, I know there are decent people who use gg to make decent posts
too, and yes, I know there are good reasons why they might not be able
to use a real newsserver on occasion.)

[Real Troll]

On 09/06/2021 16:55, David Brown wrote:
>
> Both Skybuck and that weird Italian all-caps poster use google groups to
> send their messages. Google should just do as many regular Usenet users
> do - automatically kill any messages sent via google groups.
>

The Italian chap is attacking a prominent lawyer based in ITALY and the
Lawyer must have complained about it.  Also, AIOE have closed down one
newsgroup about the same topic on the Italian Lawyer.  AIOE is an
Italian based Newsserver but they were forced to remove anything related
to that Lawyer and so Paulo who runs that server decided to host it in
Germany (but removed the newsgroup about that Lawyer because of EU
cooperation and Germany is part of the EU) where laws are a bit relaxed
about free speech.

As far a SkyBuck is concerned, all media outlets have banned anything
that questions the existence of Covid and challenges lockdowns. 
Aanother topic that was banned was "Donald Trump".  I don't know whether
the ban is still there or has it been relaxed. Youtube removed many
videos supporting Trumps views!

[Öö Tiib]

Censoring Internet. :D Smells like North Korea. Did U.S. have Communist
coup d'état ?

[Real Troll]

On 09/06/2021 20:23, Öö Tiib wrote:
> Censoring Internet. :D Smells like North Korea. Did U.S. have Communist
> coup d'état ?

Biden is in charge (he is a socialist).  You can say Biden is a good
president but you can't say Trump was a better president as he
controlled migration at a time when crime rate in United States was
going up.  There is one African American saying that America is not a
racist country.  He said African Americans make 13% of the population
but they commit 60% of the crime and those 13% are all not criminals. 
So you know statistically who commits more crime!!.

You can't blame the police for profiling the criminals as they needs to
target those who are likely to commit crime.  I can post the video here
but people may not like it so I won't.

Political correctness has gone mad and lefties have taken control of
this planet.  Common Sense is no where to be seen these days. The WOKE
brigade are in charge.  Our BBC is now called "Black Broadcasting
Corporation" and there are more programs about blacks then general
entertaining programs.  I have cancelled my license and now I use my TV
as my PC monitor.  I watch only YouTube where I get American TV News
programs.

[David Brown]

On 09/06/2021 23:10, Real Troll wrote:
> On 09/06/2021 20:23, Öö Tiib wrote:
>> Censoring Internet. :D Smells like North Korea. Did U.S. have Communist
>> coup d'état ?
>

<snip>

Please don't try to start political wars here. This is an international
group, not an American group, and it is for C++, not a politics group.

Comments about the group's removal from Google Groups, and what (if
anything) can be done to reverse that are on topic. General discussions
about censorship, for or against, are not.

If you want to talk politics in a technical group, go to
sci.electronics.design. It is a discussion group for politics,
religion, etc., with an occasional thread on electronics. But put on
your asbestos underwear first - some of the regulars there are really
unpleasant characters.

[Keith Thompson]

David Brown <david...@hesbynett.no> writes:
> On 09/06/2021 23:10, Real Troll wrote:
>> On 09/06/2021 20:23, Öö Tiib wrote:
>>> Censoring Internet. :D Smells like North Korea. Did U.S. have Communist
>>> coup d'état ?
>
> <snip>
>
> Please don't try to start political wars here. This is an international
> group, not an American group, and it is for C++, not a politics group.

The name "Real Troll" should be a clue that this person is not going to
pay attention to complaints. The solution is left as an exercise for
your killfile.

[snip]

--
Keith Thompson (The_Other_Keith) Keith.S.T...@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */

[Real Troll]

On 10/06/2021 08:44, David Brown wrote:
> On 09/06/2021 23:10, Real Troll wrote:
>> On 09/06/2021 20:23, Öö Tiib wrote:
>>> Censoring Internet. :D Smells like North Korea. Did U.S. have Communist
>>> coup d'état ?
> <snip>
>
> Please don't try to start political wars here. This is an international
> group, not an American group, and it is for C++, not a politics group.
>

Please don't attribute anything to people when they didn't post what you
attributed here.  Attention to detail is a must in these newsgroups.  If
you want to carelessly accuse people than there are other newsgroups
such as " misc.survivalism ".

[Real Troll]

On 10/06/2021 15:56, Keith Thompson wrote:
> The solution is left as an exercise for
> your killfile.

Can you kill file me too, please? I promise to offend you. All drama
queens find me offensive.

[Öö Tiib]

Estonia was still part of Communist country when I first reached Usenet
using modem, phone, and calling to number of KTH Royal Institute of
Technology in Sweden that also involved some tricks that weren't legal
by local legislature. So it is symbolic for me and attempts to censor
it are also symbolic for me and discussing it is not Real Troll's fault
but mine.

[Chris M. Thomasson]

On 1/27/2021 9:23 PM, Chris M. Thomasson wrote:

Hey at least my name is still in here:

https://www.1024cores.net/home/lock-free-algorithms/object-life-time-management/differential-reference-counting/implementation

;^)

[Manfred]

As far as I am concerned, I don't think there was any fault.

c.l.c and c.l.c++ are about the languages, so their topicality is clear,
but they are also part of Usenet, for which freedom (with no
compromises, as the Internet was originally thought of when it was made
public) is a distinctive character.
So, up to some extent, the occasional comment about free speech and
concern for censorship (which I agree is becoming more and more a real
issue) is still appropriate.

Thanks for sharing.