Index: boost/uuid/uuid.hpp =================================================================== --- boost/uuid/uuid.hpp (revision 86326) +++ boost/uuid/uuid.hpp (working copy) @@ -28,20 +28,23 @@ // 28 Nov 2009 - disabled deprecated warnings for MSVC // 30 Nov 2009 - used BOOST_STATIC_CONSTANT // 02 Dec 2009 - removed BOOST_STATIC_CONSTANT - not all compilers like it +// 29 Apr 2013 - added support for noexcept and constexpr, added optimizations for SSE/AVX #ifndef BOOST_UUID_HPP #define BOOST_UUID_HPP -#include -#include +#include #include -#include -#include // for static assert +#include #ifndef BOOST_UUID_NO_TYPE_TRAITS #include #include #endif +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + #if defined(_MSC_VER) #pragma warning(push) // Save warning settings. #pragma warning(disable : 4996) // Disable deprecated std::swap_ranges, std::equal @@ -69,28 +72,20 @@ typedef std::ptrdiff_t difference_type; // This does not work on some compilers - // They seem to want the variable definec in + // They seem to want the variable definec in // a cpp file //BOOST_STATIC_CONSTANT(size_type, static_size = 16); - static size_type static_size() { return 16; } + static BOOST_CONSTEXPR size_type static_size() BOOST_NOEXCEPT { return 16; } public: - iterator begin() { return data; } /* throw() */ - const_iterator begin() const { return data; } /* throw() */ - iterator end() { return data+size(); } /* throw() */ - const_iterator end() const { return data+size(); } /* throw() */ + iterator begin() BOOST_NOEXCEPT { return data; } + const_iterator begin() const BOOST_NOEXCEPT { return data; } + iterator end() BOOST_NOEXCEPT { return data+size(); } + const_iterator end() const BOOST_NOEXCEPT { return data+size(); } - size_type size() const { return static_size(); } /* throw() */ + BOOST_CONSTEXPR size_type size() const BOOST_NOEXCEPT { return static_size(); } - bool is_nil() const /* throw() */ - { - for(size_t i=0; i uint8_t data[16]; }; -inline bool operator==(uuid const& lhs, uuid const& rhs) /* throw() */ -{ - return std::equal(lhs.begin(), lhs.end(), rhs.begin()); -} +bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT; +bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT; -inline bool operator!=(uuid const& lhs, uuid const& rhs) /* throw() */ +inline bool operator!=(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { return !(lhs == rhs); } -inline bool operator<(uuid const& lhs, uuid const& rhs) /* throw() */ +inline bool operator>(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { - return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); -} - -inline bool operator>(uuid const& lhs, uuid const& rhs) /* throw() */ -{ return rhs < lhs; } -inline bool operator<=(uuid const& lhs, uuid const& rhs) /* throw() */ +inline bool operator<=(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { return !(rhs < lhs); } -inline bool operator>=(uuid const& lhs, uuid const& rhs) /* throw() */ +inline bool operator>=(uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { return !(lhs < rhs); } -inline void swap(uuid& lhs, uuid& rhs) /* throw() */ +inline void swap(uuid& lhs, uuid& rhs) BOOST_NOEXCEPT { lhs.swap(rhs); } // This is equivalent to boost::hash_range(u.begin(), u.end()); -inline std::size_t hash_value(uuid const& u) /* throw() */ +inline std::size_t hash_value(uuid const& u) BOOST_NOEXCEPT { std::size_t seed = 0; - for(uuid::const_iterator i=u.begin(); i != u.end(); ++i) + for(uuid::const_iterator i=u.begin(), e=u.end(); i != e; ++i) { seed ^= static_cast(*i) + 0x9e3779b9 + (seed << 6) + (seed >> 2); } @@ -214,6 +199,12 @@ } // namespace boost #endif +#if defined(BOOST_UUID_USE_SSE2) +#include +#else +#include +#endif + #if defined(_MSC_VER) #pragma warning(pop) // Restore warnings to previous state. #endif Index: boost/uuid/detail/config.hpp =================================================================== --- boost/uuid/detail/config.hpp (revision 0) +++ boost/uuid/detail/config.hpp (working copy) @@ -0,0 +1,62 @@ +/* + * Copyright Andrey Semashev 2013. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +/*! + * \file uuid/detail/config.hpp + * + * \brief This header defines configuration macros for Boost.UUID. + */ + +#ifndef BOOST_UUID_DETAIL_CONFIG_HPP_INCLUDED_ +#define BOOST_UUID_DETAIL_CONFIG_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if !defined(BOOST_UUID_NO_SIMD) + +#if defined(__GNUC__) && defined(__SSE2__) + +// GCC and its pretenders go here +#ifndef BOOST_UUID_USE_SSE2 +#define BOOST_UUID_USE_SSE2 +#endif + +#if defined(__SSE3__) && !defined(BOOST_UUID_USE_SSE3) +#define BOOST_UUID_USE_SSE3 +#endif + +#if defined(__SSE4_1__) && !defined(BOOST_UUID_USE_SSE41) +#define BOOST_UUID_USE_SSE41 +#endif + +#elif defined(_MSC_VER) && (defined(_M_X64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2)) + +#ifndef BOOST_UUID_USE_SSE2 +#define BOOST_UUID_USE_SSE2 +#endif + +#elif !defined(BOOST_UUID_USE_SSE41) && !defined(BOOST_UUID_USE_SSE3) && !defined(BOOST_UUID_USE_SSE2) + +#define BOOST_UUID_NO_SIMD + +#endif + +// More advanced ISA extensions imply less advanced are also available +#if !defined(BOOST_UUID_USE_SSE3) && defined(BOOST_UUID_USE_SSE41) +#define BOOST_UUID_USE_SSE3 +#endif + +#if !defined(BOOST_UUID_USE_SSE2) && defined(BOOST_UUID_USE_SSE3) +#define BOOST_UUID_USE_SSE2 +#endif + +#endif // !defined(BOOST_UUID_NO_SIMD) + +#endif // BOOST_UUID_DETAIL_CONFIG_HPP_INCLUDED_ Property changes on: boost/uuid/detail/config.hpp ___________________________________________________________________ Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Index: boost/uuid/detail/uuid_x86.hpp =================================================================== --- boost/uuid/detail/uuid_x86.hpp (revision 0) +++ boost/uuid/detail/uuid_x86.hpp (working copy) @@ -0,0 +1,109 @@ +/* + * Copyright Andrey Semashev 2013. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +/*! + * \file uuid/detail/uuid_x86.hpp + * + * \brief This header contains optimized SSE implementation of \c boost::uuid operations. + */ + +#ifndef BOOST_UUID_DETAIL_UUID_X86_HPP_INCLUDED_ +#define BOOST_UUID_DETAIL_UUID_X86_HPP_INCLUDED_ + +// MSVC does not always have immintrin.h (at least, not up to MSVC 10), so include the appropriate header for each instruction set +#if defined(BOOST_UUID_USE_SSE41) +#include +#elif defined(BOOST_UUID_USE_SSE3) +#include +#else +#include +#endif + +namespace boost { +namespace uuids { +namespace detail { + +BOOST_FORCEINLINE __m128i load_unaligned_si128(const uint8_t* p) BOOST_NOEXCEPT +{ +#if defined(BOOST_UUID_USE_SSE3) + return _mm_lddqu_si128(reinterpret_cast< const __m128i* >(p)); +#else + return _mm_loadu_si128(reinterpret_cast< const __m128i* >(p)); +#endif +} + +} // namespace detail + +inline bool uuid::is_nil() const BOOST_NOEXCEPT +{ + register __m128i mm = uuids::detail::load_unaligned_si128(data); +#if defined(BOOST_UUID_USE_SSE41) + return _mm_test_all_zeros(mm, mm) != 0; +#else + mm = _mm_cmpeq_epi8(mm, _mm_setzero_si128()); + return _mm_movemask_epi8(mm) == 0xFFFF; +#endif +} + +inline void uuid::swap(uuid& rhs) BOOST_NOEXCEPT +{ + register __m128i mm_this = uuids::detail::load_unaligned_si128(data); + register __m128i mm_rhs = uuids::detail::load_unaligned_si128(rhs.data); + _mm_storeu_si128(reinterpret_cast< __m128i* >(rhs.data), mm_this); + _mm_storeu_si128(reinterpret_cast< __m128i* >(data), mm_rhs); +} + +inline bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT +{ + register __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data); + register __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data); + + register __m128i mm_cmp = _mm_cmpeq_epi32(mm_left, mm_right); +#if defined(BOOST_UUID_USE_SSE41) + return _mm_test_all_ones(mm_cmp); +#else + return _mm_movemask_epi8(mm_cmp) == 0xFFFF; +#endif +} + +inline bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT +{ + register __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data); + register __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data); + + // To emulate lexicographical_compare behavior we have to perform two comparisons - the forward and reverse one. + // Then we know which bytes are equivalent and which ones are different, and for those different the comparison results + // will be opposite. Then we'll be able to find the first differing comparison result (for both forward and reverse ways), + // and depending on which way it is for, this will be the result of the operation. There are a few notes to consider: + // + // 1. Due to little endian byte order the first bytes go into the lower part of the xmm registers, + // so the comparison results in the least significant bits will actually be the most signigicant for the final operation result. + // This means we have to determine which of the comparison results have the least significant bit on, and this is achieved with + // the "(x - 1) ^ x" trick. + // 2. Because there is only signed comparison in SSE/AVX, we have to invert byte comparison results whenever signs of the corresponding + // bytes are different. I.e. in signed comparison it's -1 < 1, but in unsigned it is the opposite (255 > 1). To do that we XOR left and right, + // making the most significant bit of each byte 1 if the signs are different, and later apply this mask with another XOR to the comparison results. + // 3. pcmpgtw compares for "greater" relation, so we swap the arguments to get what we need. + + const __m128i mm_signs_mask = _mm_xor_si128(mm_left, mm_right); + + __m128i mm_cmp = _mm_cmpgt_epi8(mm_right, mm_left), mm_rcmp = _mm_cmpgt_epi8(mm_left, mm_right); + + mm_cmp = _mm_xor_si128(mm_signs_mask, mm_cmp); + mm_rcmp = _mm_xor_si128(mm_signs_mask, mm_rcmp); + + uint32_t cmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_cmp)), rcmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_rcmp)); + + cmp = (cmp - 1u) ^ cmp; + rcmp = (rcmp - 1u) ^ rcmp; + + return static_cast< uint16_t >(cmp) < static_cast< uint16_t >(rcmp); +} + +} // namespace uuids +} // namespace boost + +#endif // BOOST_UUID_DETAIL_UUID_X86_HPP_INCLUDED_ Property changes on: boost/uuid/detail/uuid_x86.hpp ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: boost/uuid/detail/uuid_generic.hpp =================================================================== --- boost/uuid/detail/uuid_generic.hpp (revision 0) +++ boost/uuid/detail/uuid_generic.hpp (working copy) @@ -0,0 +1,51 @@ +/* + * Copyright Andy Tompkins 2006. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +/*! + * \file uuid/detail/uuid_generic.hpp + * + * \brief This header contains generic implementation of \c boost::uuid operations. + */ + +#ifndef BOOST_UUID_DETAIL_UUID_GENERIC_HPP_INCLUDED_ +#define BOOST_UUID_DETAIL_UUID_GENERIC_HPP_INCLUDED_ + +#include + +namespace boost { +namespace uuids { + +inline bool uuid::is_nil() const BOOST_NOEXCEPT +{ + for (std::size_t i = 0; i < sizeof(data); ++i) + { + if (data[i] != 0U) + return false; + } + return true; +} + +inline void uuid::swap(uuid& rhs) BOOST_NOEXCEPT +{ + uuid tmp = *this; + *this = rhs; + rhs = tmp; +} + +inline bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT +{ + return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) == 0; +} + +inline bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT +{ + return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) < 0; +} + +} // namespace uuids +} // namespace boost + +#endif // BOOST_UUID_DETAIL_UUID_GENERIC_HPP_INCLUDED_ Property changes on: boost/uuid/detail/uuid_generic.hpp ___________________________________________________________________ Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Index: libs/uuid/test/test_uuid.cpp =================================================================== --- libs/uuid/test/test_uuid.cpp (revision 86326) +++ libs/uuid/test/test_uuid.cpp (working copy) @@ -156,6 +156,8 @@ uuid u1 = {{0}}; uuid u2 = {{1,0}}; uuid u3 = {{255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}}; + uuid u4 = {{0,1,0}}; + uuid u5 = {{0,255,0}}; BOOST_TEST_EQ(u1, u1); @@ -163,6 +165,11 @@ BOOST_TEST(u1 < u2); BOOST_TEST(u2 < u3); + BOOST_TEST(u1 < u4); + BOOST_TEST(u1 < u5); + BOOST_TEST(u4 < u5); + BOOST_TEST(u4 < u2); + BOOST_TEST(u5 < u2); BOOST_TEST(u1 <= u1); BOOST_TEST(u1 <= u2);