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....

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 ).

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

https://github.com/bloomberg/bde

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.

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

> 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.

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.

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.

Main Benefits:

- customizable allocators and alignment

- designed with turning off exceptions in mind

- performance improvements(especially map and list)

- portable between different C++ vendors