Appender is ... slow

[Jonathan M Davis via Digitalmars-d-learn]

On Thursday, 14 August 2014 at 19:29:28 UTC, Philippe Sigaud via 
Digitalmars-d-learn wrote:
>> It sounds like you're trying to use it as a way to manage 
>> reusing
>> the array, and I have no idea how it works for that.
>
> There is a misunderstanding there: I'm using clear only to 
> flush the
> state at the beginning of the computation. The Appender is a 
> class
> field, used by the class methods to calculate. If I do not 
> clear it at
> the beginning of the methods, I keep appending new results to 
> old
> computations, which is not what I want. But really, calling 
> clear is a
> minor point: I'm interested in Appender's effect on *one* (long,
> concatenation-intensive) computation.

Then it sounds like you're reusing the Appender. I've never done 
that. In fact, I would have assumed that that would mean that you 
were attempted to fill in the same array again, and I wouldn't 
have even thought that that was safe, because I would have 
assumed that Appnder used assumeSafeAppend, which would mean that 
reusing the Appender would be highly unsafe unless you weren't 
using the array that you got from it anymore.

I always use Appender to construct an array, and then I get rid 
of the Appender. I don't think that I've ever had a member 
variable which was an Appender. I only ever use it for local 
variables or function arguments.

>> I've
>> never actually benchmarked it for just creating arrays via 
>> appending. I'd
>> just assumed that it was faster than just using ~=, because 
>> that's what it's
>> supposedly for. But maybe I just completely misunderstood what 
>> the point of
>> Appender was.
>
> I don't know. People here keep telling newcomers to use it, but 
> I'm
> not convinced by its results. Maybe I'm seeing worse results 
> because
> my arrays are do not have millions of elements and Appender 
> shines for
> long arrays?

I have no idea. It was my understandnig that it was faster to 
create an array via appending using Appender than ~=, but I've 
never benchmarked it or actually looked into how it works. It's 
quite possible that while it's _supposed_ to be faster, it's 
actually flawed somehow and is actually slower, and no one has 
noticed previously, simply assuming that it was faster because 
it's supposed to be.

- Jonathan M Davis