Darren New <dne### [at] sanrrcom> wrote:
> Warp wrote:
> >   Oh, of course handling more data than the natural pointer size of the
> > system is very efficient. It's just the reference counter which is
> > inefficient because it has to be able to count more than the natural
> > word size. Everything else is efficient even though everything else
> > also needs to handle values larger than the natural word size. Yes,
> > makes sense. Or then not.

> Thank you for that lovely strawman.

  I think that you just used a kind of "meta-strawman": Your accusation
of me making a "strawman" argument was a strawman in itself. It's an
easy way of disregarding a valid argument.

  My point is very valid. You complain that handling reference counts
larger than the natural word size of the system is inefficient, yet you
don't take into account that *every* data handling in that same program
would be inefficient too because of the exact same reason (having to
handle values larger than the word size) and thus the "inefficiency"
of the reference counter gets more or less buried under the inefficiency
of everything else. In other words, the reference counter adds only just
a very small percentage to the total inefficiency of the program and thus
is negligible.

> >   Doesn't sound like a very smart thing to do. Sounds like over-optimization.

> When you're trying to put 20,000 objects into 64K of ram, yes, it's 
> actually quite a smart thing to do.

  I wouldn't use a GC engine in a 64K system either. We are comparing
reference counting to GC here.

> Reference counting doesn't solve the problem of knowing when to collect 
> the garbage. It's inefficient in both time and space, it causes 
> unpredictable performance by requiring large amounts of time to free 
> arbitrarily large structures all at once due to cascading reference 
> counts going to zero, and virtually nobody who knows anything about 
> garbage collection uses it anymore.

  Unpredictable? :D

  A reference counting system is exactly the opposite: You know exactly
when things are freed and how much is freed. It's the Java-style GC which
is completely unpredictable.
  You have somehow succeeded in completely turning the issue around and
are accusing RC for the exactly problem that GC has. Incredible.

-- 
                                                          - Warp

Post a reply to this message