Data Structure Choosing Tool

Background:
Concurrent data structure implementations given in libraries are usually to general to provide much
speed up. The speed up seen in concurrent objects comes from optimizing the algorithms to the
hardware and the use case.
An example of this would be a concurrent vector, if the use case consists of only push operations and
no pop operations (we can support random access read, and random access write). This use can can be
implemented with an atomic fetch and add. With conflicting concurrent operations such as push and
pop, our tail pointer would have to be maintained with a compare-and-swap atomic primitive known as
CAS. These CAS operations are more costly than fetch and add and we would like to avoid them when
possible.
Atomic Primitives: http://en.cppreference.com/w/cpp/atomic
Algorithm libraries cannot optimize for these special use cases, understandably. However the
motivation for using a library is that the library user does not have to be an expert in the field of
algorithm implementations found in these libraries. This motivates an interesting area of work in
automated data structure selection. Given a library of implementations of the same data structure and
use case clues from the user, we can create an algorithm that can make the decision of optimal selection
for the user.
Problem:
Program an implementation of one of these data structure selection algorithms. This could use a
decision tree that branches based on user input, machine learning, static analysis, dynamic analysis, or
some other unique approach or combination of appraoches.
Related Works:
Peter Hawkins, Alex Aiken, Kathleen Fisher, Martin Rinard, and Mooly Sagiv. Concurrent data
representation synthesis. SIGPLAN Not., 47(6):417428, June 2012.
Changhee Jung, Silvius Rus, Brian P. Railing, Nathan Clark, and Santosh Pande. Brainy: effective
selection of data structures. SIGPLAN Not., 47(6):8697, June 2011.
Lixia Liu and Silvius Rus. Perflint: A context sensitive performance advisor for c++ programs. In
Proceedings of the CGO 2009, The Seventh International Symposium on Code Generation and
Optimization, Seattle, Washington, USA, March 22-25, 2009, pages 265274. IEEE Computer Society,
2009.
Martin Vechev and Eran Yahav. Deriving linearizable fine-grained concurrent objects. SIGPLAN Not.,
43(6):125135, June 2008
Guoqing Xu and Atanas Rountev. Detecting inefficiently-used containers to avoid bloat. SIGPLAN
Not., 45(6):160173, June 2010.