Add support for 128-bit compare and swap on x86_64 when available.

A 128-bit compare-and-swap will enable a better atomic lifo implementation
that uses the pointer + counter method to avoid ABA issues. This commit
adds configury to check for the instruction (cmpxchg16b) and adds an
implementation that uses the __int128 type available in C99.
Define opal_int128_t type if a 128-bit integer is available.

There currently is no standard support for 128-bit integer types. Any use
of the __int128 and int128_t types can lead to warnings from the compiler
when using -Wpedantic. Additionally, some compilers may support __int128
and other may support int128_t. This commit addresses both issues by
defining opal_int128_t if there is a supported 128-bit type. In the
case of GCC a pragma has been added to suppress warnings about __int128
not being a standard C type.
Fix return type of opal_atomic_cmpset_128.

The return type will be opal_int128_t after the fetching atomics
changes but for now it is int.
Add support for __sync builtin compare and swap on 128-bit values
minor cray pmi config cleanup
minor ugni config cleanup
Further cleanups on the LSF integration - the affinity file is apparently always present, but simply empty if affinity wasn't set.
Fix typo
Add check for -mcx16 flag for 128-bit compare and swap

Some versions of gcc require this flag to be set before the __sync
builtin atomic compare and swap will support 128-bit values. If the
flag is required this check adds the flag to the CFLAGS.
Merge pull request #297 from hjelmn/topic/cmpset128

Add support for 128-bit compare and swap on x86_64 when available.
Adjust cmpxchg16b clobber list
Rename opal_atomic_lifo_t to opal_lifo_t and improve interface

 - Rename opal_atomic_lifo_t to opal_lifo_t to reflect both atomic and
   non-atomic usage. Added new routines (opal_lifo_*_st) for non-atomic
   usage as well as routines conditioned off opal_using_threads(). The
   atomic versions are always thread safe and the non-atomic are always
   not thread safe.

 - Add a new atomic lifo implementation that makes use of 128-bit
   compare-and-swap. The new implementation should scale better with
   larger numbers of threads.

 - Add threading unit test for opal_lifo_t.
Add opal_fifo_t class

This commit adds a new class: opal_fifo.h. The new class has atomic, non-atomic,
and opal_using_threads() conditoned routines. It should be used when first-in
first-out is required and should perform much better than using locks and an
opal_list_t. Like with opal_lifo_t there are two versions of the atomic
implementation: 128-bit compare-and-swap, and spin-locked. More implementations
can be added later (LL/SC comes to mind).

This commit also adds a unit test for the opal_fifo_t class. This test verifies
the fifo implementation when using multiple threads.