Boost logo

Boost Users :

Subject: Re: [Boost-users] Query regarding interest in my submitting plf::colony to Boost
From: Gonzalo BG (gonzalobg88_at_[hidden])
Date: 2015-07-13 18:22:32

This looks interesting. I am trying to understand what colony does and how
it from the docs, but I have some questions.
I haven't looked at the code yet, but I hope this questions and feedback
can help you improve the docs for those who might come after me.

> You cannot subtract the value of the .begin() iterator from the current
position iterator to get a colony "index" number like you would with

- What concept does the colony iterator model? This is never stated, but I
would assume that they are RandomAccessIterators from the context. Still,
the point 10. in the FAQ "Will a [ ] operator be added?" suggests that I'm
wrong. This needs to be stated explicitly. Otherwise I don't know which
algorithms can I use on colony iterators.

- What is the algorithmic complexity of the operations? I am interested in
add, erase, find, find_all, size.

- What is the exception safety guarantees of the operations mentioned above?

- What is the exact data-structure that the colony uses? You specify it up
to some point, and add somewhere later that it grows like a vector. From
the docs I don't know the details, and I really would like to: what is the
growth factor, how much memory per element does it need (at least a flag
specifying if it is in use or not right?).

- Why does colony need a find member function? (Or in other words, why
doesn't std::find work?)
- Why is find_all a member function? (Why cannot/should not be implemented
as a non-member non-friend with colony::find?)

In general, I cannot interpret any single benchmark since they are
unspecified. I would like to know exactly what each benchmarks does, that
is, which steps are timed, and maybe how the benchmarks looks (a bit of
pseudocode or C++ would be ok here, or a link to the benchmark file).

Even without this information, a couple of benchmarks look "strange":

- How come colony is 1.5x faster than vector in the "test 1: Iterating over
all elements 100 times and add random unsigned int member to a total"?
I would expect this to be the best possible case for vector, and from the
description of colony's data-structure, I don't see how iteration can be
faster for colony.

- Clearing a colony is 20x faster than clearing a vector. Since clearing a
vector just calls the destructors of the elements, I really don't know how
a colony can do less work than this. Is it destroying the elements? What is
vector doing that colony isn't?

And that's it for the questions, i'm going to dive in the code next.

P.S: I think there is a typo in the docs here:

> iterator add(const the_type &&element)
> Moves the element supplied to the colony, using the object's

The "const" should not be there, or otherwise one cannot move "element"
into the colony without const_cast tricks.

Boost-users list run by williamkempf at, kalb at, bjorn.karlsson at, gregod at, wekempf at