more speed

You can find videos of Stroustrup explaining why std::multimap is so slow^※(注記). See Why you shouldn't use set (and what you should use instead) by Matt Austern.

Use Boost.Container for flat_(multi)map which is a mature implementation based on Matt’s article, via Andrei Alexandrescu.

As a drop-in replacement, see what that does for your speed!

multimap.emplace_hint(range.first, std::make_pair(temp.hash, temp.move()));

That can (now) be written much more simply:

multimap.emplace_hint(range.first, { temp.hash, temp.move() } );

if (node->data.value == false)

Testing a bool against true/false is just strange. It is a bool; use it.

if (!node->data.value)

while (node != nullptr)

Don’t explicitly test against nullptr. Use the the truth value of the pointer’s value, which might (in the case of smart pointers) be an efficient operator bool in the class.

while (node)

#addendum

※(注記) A flat map wins for looking things up, which in my experience is the bulk of the run. The tree-based map will start beating flat-map for inserts and deletes at some size n and continue pulling ahead since the k₁∙O(log n) is a better order than k₂∙O(n) even when k₂ is much smaller than k₁.

more speed

You can find videos of Stroustrup explaining why std::multimap is so slow^※(注記). See Why you shouldn't use set (and what you should use instead) by Matt Austern.

Use Boost.Container for flat_(multi)map which is a mature implementation based on Matt’s article, via Andrei Alexandrescu.

As a drop-in replacement, see what that does for your speed!

multimap.emplace_hint(range.first, std::make_pair(temp.hash, temp.move()));

That can (now) be written much more simply:

multimap.emplace_hint(range.first, { temp.hash, temp.move() } );

if (node->data.value == false)

Testing a bool against true/false is just strange. It is a bool; use it.

if (!node->data.value)

while (node != nullptr)

Don’t explicitly test against nullptr. Use the the truth value of the pointer’s value, which might (in the case of smart pointers) be an efficient operator bool in the class.

while (node)

addendum

※(注記) A flat map wins for looking things up, which in my experience is the bulk of the run. The tree-based map will start beating flat-map for inserts and deletes at some size n and continue pulling ahead since the k₁∙O(log n) is a better order than k₂∙O(n) even when k₂ is much smaller than k₁.

more speed

You can find videos of Stroustrup explaining why std::multimap is so slow. See Why you shouldn't use set (and what you should use instead) by Matt Austern.

Use Boost.Container for flat_(multi)map which is a mature implementation based on Matt’s article, via Andrei Alexandrescu.

As a drop-in replacement, see what that does for your speed!

multimap.emplace_hint(range.first, std::make_pair(temp.hash, temp.move()));

That can (now) be written much more simply:

multimap.emplace_hint(range.first, { temp.hash, temp.move() } );

if (node->data.value == false)

Testing a bool against true/false is just strange. It is a bool; use it.

if (!node->data.value)

while (node != nullptr)

Don’t explicitly test against nullptr. Use the the truth value of the pointer’s value, which might (in the case of smart pointers) be an efficient operator bool in the class.

while (node)

more speed

You can find videos of Stroustrup explaining why std::multimap is so slow^※(注記). See Why you shouldn't use set (and what you should use instead) by Matt Austern.

Use Boost.Container for flat_(multi)map which is a mature implementation based on Matt’s article, via Andrei Alexandrescu.

As a drop-in replacement, see what that does for your speed!

multimap.emplace_hint(range.first, std::make_pair(temp.hash, temp.move()));

That can (now) be written much more simply:

multimap.emplace_hint(range.first, { temp.hash, temp.move() } );

if (node->data.value == false)

Testing a bool against true/false is just strange. It is a bool; use it.

if (!node->data.value)

while (node != nullptr)

Don’t explicitly test against nullptr. Use the the truth value of the pointer’s value, which might (in the case of smart pointers) be an efficient operator bool in the class.

while (node)

#addendum

※(注記) A flat map wins for looking things up, which in my experience is the bulk of the run. The tree-based map will start beating flat-map for inserts and deletes at some size n and continue pulling ahead since the k₁∙O(log n) is a better order than k₂∙O(n) even when k₂ is much smaller than k₁.