Hacker News Reader

Comment by sho_hn | Hacker News Reader

Looks interesting, but the README is thin on espousing the benefits. Questions that come to mind:

- What stands out about it?

- Benchmarks?

- What platforms are supported?

- How is it differentiated today vs. 15 years ago? Qt wound up with its own 'standard library'-alike types mainly because the STL (and its implementations across platforms) were not really up to snuff when it started out. I suspect this may be similar.

- Does anyone have direct experience to share? :-)

Edit: Found some info at https://eastl.docsforge.com/master/faq/#info2-what-uses-are-... and benchmarks at https://eastl.docsforge.com/master/benchmarks/

Especially interesting for me as Linux dev: "[...] EASTL is significantly more efficient than Dinkumware STL, and Microsoft Windows STL [...] EASTL is roughly equal in efficiency to STLPort and GCC 3.x+ STL, though EASTL has some optimizations that these do not."

View on HN

It's been a long time but from what I remember the selling point for EASTL is the ability to specify your own allocator instance for every container. EA writes portable code across lots of different architectures, many of which share a lot more with embedded systems than with PCs. They have constrained memory or special dedicated memory areas. Also, iirc EA uses tagging allocators extensively letting them trace against memory budgets down to the team level.

Edit: there's an extensive FAQ in the docs folder: https://github.com/electronicarts/EASTL/blob/master/doc/FAQ....

The FAQ seems to answer the question of why EASTL is better than some extremely old and bad standard libraries, not why it is better than modern ones.

I don't know where they do their CI/CD now...they seemed to have moved off of travis. But, there's a snapshot of a benchmark from 2019 still here:

https://github.com/electronicarts/EASTL/issues/267

That was my impression of how EASTL came to be. Everybody used old and bad libraries, so they wrote ones that were better.

Imagine they wrote their own Javascript engine before V8 became really performant. That sort of thing.

Specifying your own allocator is like a main feature of bde from Bloomberg:

https://github.com/bloomberg/bde

That is accurate. That general model eventually made it into the standard, because of EA and Bloomberg ( https://en.cppreference.com/w/cpp/memory/memory_resource ).

> Does anyone have direct experience to share?

Used it a few times for some medium-complexity stuff, here’s an open-source example: https://github.com/Const-me/vis_avs_dx/tree/master/avs_dx/Dx...

Works OK, and indeed faster than VC++ (I was using VS2017 at that time), especially in debug builds.

One interesting feature missing from the standard library is segmented_vector container. https://github.com/electronicarts/EASTL/blob/master/include/...

They benchmark against Windows STL from Visual C++ 7.1 that came out in 2003!. Not sure how it compares to more modern versions much less something like abseil or Folly.

I used EASTL on a few projects and it was 10x faster in debug mode. VS had a lot of checks in debug mode and it was almost impossible to play games in debug mode. I’m haven’t used it since 2012.

I would highly recommend building with ITERATOR_DEBUG_LEVEL=0 in debug mode.

It can be a bit annoying because all other libraries you link with must also be have this set the same.

Still has lots of checks in debug mode, it is what makes C++ enjoyable from security point of view.

Those that prefer cars without seatbelts, or motorbikes without helmets, can #define them away.

Main Benefits:

- customizable allocators and alignment

- designed with turning off exceptions in mind

- performance improvements(especially map and list)

- portable between different C++ vendors

Don't forget about micro transactions and loot boxes.

Reply on news.ycombinator.com