pliard@google.com
13 years ago
parent
cb6dd4ef5f
commit
f5de486b53
13 changed files with 1660 additions and 0 deletions
@ -0,0 +1,179 @@ |
||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// The routines exported by this module are subtle. If you use them, even if
|
||||
// you get the code right, it will depend on careful reasoning about atomicity
|
||||
// and memory ordering; it will be less readable, and harder to maintain. If
|
||||
// you plan to use these routines, you should have a good reason, such as solid
|
||||
// evidence that performance would otherwise suffer, or there being no
|
||||
// alternative. You should assume only properties explicitly guaranteed by the
|
||||
// specifications in this file. You are almost certainly _not_ writing code
|
||||
// just for the x86; if you assume x86 semantics, x86 hardware bugs and
|
||||
// implementations on other archtectures will cause your code to break. If you
|
||||
// do not know what you are doing, avoid these routines, and use a Mutex.
|
||||
//
|
||||
// It is incorrect to make direct assignments to/from an atomic variable.
|
||||
// You should use one of the Load or Store routines. The NoBarrier
|
||||
// versions are provided when no barriers are needed:
|
||||
// NoBarrier_Store()
|
||||
// NoBarrier_Load()
|
||||
// Although there are currently no compiler enforcement, you are encouraged
|
||||
// to use these.
|
||||
|
||||
// This header and the implementations for each platform (located in
|
||||
// atomicops_internals_*) must be kept in sync with the upstream code (V8).
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_H_ |
||||
|
||||
// Don't include this file for people not concerned about thread safety.
|
||||
#ifndef GOOGLE_PROTOBUF_NO_THREADSAFETY |
||||
|
||||
#include <google/protobuf/stubs/platform_macros.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
typedef int32 Atomic32; |
||||
#ifdef GOOGLE_PROTOBUF_HOST_ARCH_64_BIT |
||||
// We need to be able to go between Atomic64 and AtomicWord implicitly. This
|
||||
// means Atomic64 and AtomicWord should be the same type on 64-bit.
|
||||
#if defined(__APPLE__) |
||||
// MacOS is an exception to the implicit conversion rule above,
|
||||
// because it uses long for intptr_t.
|
||||
typedef int64 Atomic64; |
||||
#else |
||||
typedef intptr_t Atomic64; |
||||
#endif |
||||
#endif |
||||
|
||||
// Use AtomicWord for a machine-sized pointer. It will use the Atomic32 or
|
||||
// Atomic64 routines below, depending on your architecture.
|
||||
typedef intptr_t AtomicWord; |
||||
|
||||
// Atomically execute:
|
||||
// result = *ptr;
|
||||
// if (*ptr == old_value)
|
||||
// *ptr = new_value;
|
||||
// return result;
|
||||
//
|
||||
// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
|
||||
// Always return the old value of "*ptr"
|
||||
//
|
||||
// This routine implies no memory barriers.
|
||||
Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value); |
||||
|
||||
// Atomically store new_value into *ptr, returning the previous value held in
|
||||
// *ptr. This routine implies no memory barriers.
|
||||
Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value); |
||||
|
||||
// Atomically increment *ptr by "increment". Returns the new value of
|
||||
// *ptr with the increment applied. This routine implies no memory barriers.
|
||||
Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment); |
||||
|
||||
Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment); |
||||
|
||||
// These following lower-level operations are typically useful only to people
|
||||
// implementing higher-level synchronization operations like spinlocks,
|
||||
// mutexes, and condition-variables. They combine CompareAndSwap(), a load, or
|
||||
// a store with appropriate memory-ordering instructions. "Acquire" operations
|
||||
// ensure that no later memory access can be reordered ahead of the operation.
|
||||
// "Release" operations ensure that no previous memory access can be reordered
|
||||
// after the operation. "Barrier" operations have both "Acquire" and "Release"
|
||||
// semantics. A MemoryBarrier() has "Barrier" semantics, but does no memory
|
||||
// access.
|
||||
Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value); |
||||
Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value); |
||||
|
||||
void MemoryBarrier(); |
||||
void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value); |
||||
void Acquire_Store(volatile Atomic32* ptr, Atomic32 value); |
||||
void Release_Store(volatile Atomic32* ptr, Atomic32 value); |
||||
|
||||
Atomic32 NoBarrier_Load(volatile const Atomic32* ptr); |
||||
Atomic32 Acquire_Load(volatile const Atomic32* ptr); |
||||
Atomic32 Release_Load(volatile const Atomic32* ptr); |
||||
|
||||
// 64-bit atomic operations (only available on 64-bit processors).
|
||||
#ifdef GOOGLE_PROTOBUF_HOST_ARCH_64_BIT |
||||
Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value); |
||||
Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value); |
||||
Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment); |
||||
Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment); |
||||
|
||||
Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value); |
||||
Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value); |
||||
void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value); |
||||
void Acquire_Store(volatile Atomic64* ptr, Atomic64 value); |
||||
void Release_Store(volatile Atomic64* ptr, Atomic64 value); |
||||
Atomic64 NoBarrier_Load(volatile const Atomic64* ptr); |
||||
Atomic64 Acquire_Load(volatile const Atomic64* ptr); |
||||
Atomic64 Release_Load(volatile const Atomic64* ptr); |
||||
#endif // GOOGLE_PROTOBUF_HOST_ARCH_64_BIT
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
// Include our platform specific implementation.
|
||||
#if defined(_MSC_VER) && \ |
||||
(defined(GOOGLE_PROTOBUF_HOST_ARCH_IA32) || \
|
||||
defined(GOOGLE_PROTOBUF_HOST_ARCH_X64)) |
||||
#include "atomicops_internals_x86_msvc.h" |
||||
#elif defined(__APPLE__) && \ |
||||
(defined(GOOGLE_PROTOBUF_HOST_ARCH_IA32) || \
|
||||
defined(GOOGLE_PROTOBUF_HOST_ARCH_X64)) |
||||
#include "atomicops_internals_x86_macosx.h" |
||||
#elif defined(__GNUC__) && \ |
||||
(defined(GOOGLE_PROTOBUF_HOST_ARCH_IA32) || \
|
||||
defined(GOOGLE_PROTOBUF_HOST_ARCH_X64)) |
||||
#include "atomicops_internals_x86_gcc.h" |
||||
#elif defined(__GNUC__) && defined(GOOGLE_PROTOBUF_HOST_ARCH_ARM) |
||||
#include "atomicops_internals_arm_gcc.h" |
||||
#elif defined(__GNUC__) && defined(GOOGLE_PROTOBUF_HOST_ARCH_MIPS) |
||||
#include "atomicops_internals_mips_gcc.h" |
||||
#else |
||||
#error "Atomic operations are not supported on your platform" |
||||
#endif |
||||
|
||||
#endif // GOOGLE_PROTOBUF_NO_THREADSAFETY
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_H_
|
||||
@ -0,0 +1,148 @@ |
||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This file is an internal atomic implementation, use atomicops.h instead.
|
||||
//
|
||||
// LinuxKernelCmpxchg and Barrier_AtomicIncrement are from Google Gears.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_GCC_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_GCC_H_ |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
// 0xffff0fc0 is the hard coded address of a function provided by
|
||||
// the kernel which implements an atomic compare-exchange. On older
|
||||
// ARM architecture revisions (pre-v6) this may be implemented using
|
||||
// a syscall. This address is stable, and in active use (hard coded)
|
||||
// by at least glibc-2.7 and the Android C library.
|
||||
typedef Atomic32 (*LinuxKernelCmpxchgFunc)(Atomic32 old_value, |
||||
Atomic32 new_value, |
||||
volatile Atomic32* ptr); |
||||
LinuxKernelCmpxchgFunc pLinuxKernelCmpxchg __attribute__((weak)) = |
||||
(LinuxKernelCmpxchgFunc) 0xffff0fc0; |
||||
|
||||
typedef void (*LinuxKernelMemoryBarrierFunc)(void); |
||||
LinuxKernelMemoryBarrierFunc pLinuxKernelMemoryBarrier __attribute__((weak)) = |
||||
(LinuxKernelMemoryBarrierFunc) 0xffff0fa0; |
||||
|
||||
|
||||
inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 prev_value = *ptr; |
||||
do { |
||||
if (!pLinuxKernelCmpxchg(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, |
||||
Atomic32 new_value) { |
||||
Atomic32 old_value; |
||||
do { |
||||
old_value = *ptr; |
||||
} while (pLinuxKernelCmpxchg(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))); |
||||
return old_value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
return Barrier_AtomicIncrement(ptr, increment); |
||||
} |
||||
|
||||
inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
for (;;) { |
||||
// Atomic exchange the old value with an incremented one.
|
||||
Atomic32 old_value = *ptr; |
||||
Atomic32 new_value = old_value + increment; |
||||
if (pLinuxKernelCmpxchg(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr)) == 0) { |
||||
// The exchange took place as expected.
|
||||
return new_value; |
||||
} |
||||
// Otherwise, *ptr changed mid-loop and we need to retry.
|
||||
} |
||||
} |
||||
|
||||
inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void MemoryBarrier() { |
||||
pLinuxKernelMemoryBarrier(); |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
MemoryBarrier(); |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { |
||||
Atomic32 value = *ptr; |
||||
MemoryBarrier(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic32 Release_Load(volatile const Atomic32* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_GCC_H_
|
||||
@ -0,0 +1,184 @@ |
||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This file is an internal atomic implementation, use atomicops.h instead.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MIPS_GCC_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MIPS_GCC_H_ |
||||
|
||||
#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory") |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
// Atomically execute:
|
||||
// result = *ptr;
|
||||
// if (*ptr == old_value)
|
||||
// *ptr = new_value;
|
||||
// return result;
|
||||
//
|
||||
// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
|
||||
// Always return the old value of "*ptr"
|
||||
//
|
||||
// This routine implies no memory barriers.
|
||||
inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 prev, tmp; |
||||
__asm__ __volatile__(".set push\n" |
||||
".set noreorder\n" |
||||
"1:\n" |
||||
"ll %0, %5\n" // prev = *ptr
|
||||
"bne %0, %3, 2f\n" // if (prev != old_value) goto 2
|
||||
"move %2, %4\n" // tmp = new_value
|
||||
"sc %2, %1\n" // *ptr = tmp (with atomic check)
|
||||
"beqz %2, 1b\n" // start again on atomic error
|
||||
"nop\n" // delay slot nop
|
||||
"2:\n" |
||||
".set pop\n" |
||||
: "=&r" (prev), "=m" (*ptr), "=&r" (tmp) |
||||
: "Ir" (old_value), "r" (new_value), "m" (*ptr) |
||||
: "memory"); |
||||
return prev; |
||||
} |
||||
|
||||
// Atomically store new_value into *ptr, returning the previous value held in
|
||||
// *ptr. This routine implies no memory barriers.
|
||||
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, |
||||
Atomic32 new_value) { |
||||
Atomic32 temp, old; |
||||
__asm__ __volatile__(".set push\n" |
||||
".set noreorder\n" |
||||
"1:\n" |
||||
"ll %1, %2\n" // old = *ptr
|
||||
"move %0, %3\n" // temp = new_value
|
||||
"sc %0, %2\n" // *ptr = temp (with atomic check)
|
||||
"beqz %0, 1b\n" // start again on atomic error
|
||||
"nop\n" // delay slot nop
|
||||
".set pop\n" |
||||
: "=&r" (temp), "=&r" (old), "=m" (*ptr) |
||||
: "r" (new_value), "m" (*ptr) |
||||
: "memory"); |
||||
|
||||
return old; |
||||
} |
||||
|
||||
// Atomically increment *ptr by "increment". Returns the new value of
|
||||
// *ptr with the increment applied. This routine implies no memory barriers.
|
||||
inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
Atomic32 temp, temp2; |
||||
|
||||
__asm__ __volatile__(".set push\n" |
||||
".set noreorder\n" |
||||
"1:\n" |
||||
"ll %0, %2\n" // temp = *ptr
|
||||
"addu %1, %0, %3\n" // temp2 = temp + increment
|
||||
"sc %1, %2\n" // *ptr = temp2 (with atomic check)
|
||||
"beqz %1, 1b\n" // start again on atomic error
|
||||
"addu %1, %0, %3\n" // temp2 = temp + increment
|
||||
".set pop\n" |
||||
: "=&r" (temp), "=&r" (temp2), "=m" (*ptr) |
||||
: "Ir" (increment), "m" (*ptr) |
||||
: "memory"); |
||||
// temp2 now holds the final value.
|
||||
return temp2; |
||||
} |
||||
|
||||
inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
Atomic32 res = NoBarrier_AtomicIncrement(ptr, increment); |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
return res; |
||||
} |
||||
|
||||
// "Acquire" operations
|
||||
// ensure that no later memory access can be reordered ahead of the operation.
|
||||
// "Release" operations ensure that no previous memory access can be reordered
|
||||
// after the operation. "Barrier" operations have both "Acquire" and "Release"
|
||||
// semantics. A MemoryBarrier() has "Barrier" semantics, but does no memory
|
||||
// access.
|
||||
inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
Atomic32 res = NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
return res; |
||||
} |
||||
|
||||
inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
Atomic32 res = NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
return res; |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void MemoryBarrier() { |
||||
__asm__ __volatile__("sync" : : : "memory"); |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
MemoryBarrier(); |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { |
||||
Atomic32 value = *ptr; |
||||
MemoryBarrier(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic32 Release_Load(volatile const Atomic32* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#undef ATOMICOPS_COMPILER_BARRIER |
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MIPS_GCC_H_
|
||||
@ -0,0 +1,137 @@ |
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This module gets enough CPU information to optimize the
|
||||
// atomicops module on x86.
|
||||
|
||||
#include <cstring> |
||||
|
||||
#include "atomicops.h" |
||||
|
||||
// This file only makes sense with atomicops_internals_x86_gcc.h -- it
|
||||
// depends on structs that are defined in that file. If atomicops.h
|
||||
// doesn't sub-include that file, then we aren't needed, and shouldn't
|
||||
// try to do anything.
|
||||
#ifdef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_ |
||||
|
||||
// Inline cpuid instruction. In PIC compilations, %ebx contains the address
|
||||
// of the global offset table. To avoid breaking such executables, this code
|
||||
// must preserve that register's value across cpuid instructions.
|
||||
#if defined(__i386__) |
||||
#define cpuid(a, b, c, d, inp) \ |
||||
asm("mov %%ebx, %%edi\n" \
|
||||
"cpuid\n" \
|
||||
"xchg %%edi, %%ebx\n" \
|
||||
: "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp)) |
||||
#elif defined(__x86_64__) |
||||
#define cpuid(a, b, c, d, inp) \ |
||||
asm("mov %%rbx, %%rdi\n" \
|
||||
"cpuid\n" \
|
||||
"xchg %%rdi, %%rbx\n" \
|
||||
: "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp)) |
||||
#endif |
||||
|
||||
#if defined(cpuid) // initialize the struct only on x86
|
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
// Set the flags so that code will run correctly and conservatively, so even
|
||||
// if we haven't been initialized yet, we're probably single threaded, and our
|
||||
// default values should hopefully be pretty safe.
|
||||
struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures = { |
||||
false, // bug can't exist before process spawns multiple threads
|
||||
false, // no SSE2
|
||||
}; |
||||
|
||||
namespace { |
||||
|
||||
// Initialize the AtomicOps_Internalx86CPUFeatures struct.
|
||||
void AtomicOps_Internalx86CPUFeaturesInit() { |
||||
uint32_t eax; |
||||
uint32_t ebx; |
||||
uint32_t ecx; |
||||
uint32_t edx; |
||||
|
||||
// Get vendor string (issue CPUID with eax = 0)
|
||||
cpuid(eax, ebx, ecx, edx, 0); |
||||
char vendor[13]; |
||||
memcpy(vendor, &ebx, 4); |
||||
memcpy(vendor + 4, &edx, 4); |
||||
memcpy(vendor + 8, &ecx, 4); |
||||
vendor[12] = 0; |
||||
|
||||
// get feature flags in ecx/edx, and family/model in eax
|
||||
cpuid(eax, ebx, ecx, edx, 1); |
||||
|
||||
int family = (eax >> 8) & 0xf; // family and model fields
|
||||
int model = (eax >> 4) & 0xf; |
||||
if (family == 0xf) { // use extended family and model fields
|
||||
family += (eax >> 20) & 0xff; |
||||
model += ((eax >> 16) & 0xf) << 4; |
||||
} |
||||
|
||||
// Opteron Rev E has a bug in which on very rare occasions a locked
|
||||
// instruction doesn't act as a read-acquire barrier if followed by a
|
||||
// non-locked read-modify-write instruction. Rev F has this bug in
|
||||
// pre-release versions, but not in versions released to customers,
|
||||
// so we test only for Rev E, which is family 15, model 32..63 inclusive.
|
||||
if (strcmp(vendor, "AuthenticAMD") == 0 && // AMD
|
||||
family == 15 && |
||||
32 <= model && model <= 63) { |
||||
AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug = true; |
||||
} else { |
||||
AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug = false; |
||||
} |
||||
|
||||
// edx bit 26 is SSE2 which we use to tell use whether we can use mfence
|
||||
AtomicOps_Internalx86CPUFeatures.has_sse2 = ((edx >> 26) & 1); |
||||
} |
||||
|
||||
class AtomicOpsx86Initializer { |
||||
public: |
||||
AtomicOpsx86Initializer() { |
||||
AtomicOps_Internalx86CPUFeaturesInit(); |
||||
} |
||||
}; |
||||
|
||||
// A global to get use initialized on startup via static initialization :/
|
||||
AtomicOpsx86Initializer g_initer; |
||||
|
||||
} // namespace
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // __i386__
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_
|
||||
@ -0,0 +1,290 @@ |
||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This file is an internal atomic implementation, use atomicops.h instead.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_ |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
// This struct is not part of the public API of this module; clients may not
|
||||
// use it.
|
||||
// Features of this x86. Values may not be correct before main() is run,
|
||||
// but are set conservatively.
|
||||
struct AtomicOps_x86CPUFeatureStruct { |
||||
bool has_amd_lock_mb_bug; // Processor has AMD memory-barrier bug; do lfence
|
||||
// after acquire compare-and-swap.
|
||||
bool has_sse2; // Processor has SSE2.
|
||||
}; |
||||
extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures; |
||||
|
||||
#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory") |
||||
|
||||
// 32-bit low-level operations on any platform.
|
||||
|
||||
inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 prev; |
||||
__asm__ __volatile__("lock; cmpxchgl %1,%2" |
||||
: "=a" (prev) |
||||
: "q" (new_value), "m" (*ptr), "0" (old_value) |
||||
: "memory"); |
||||
return prev; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, |
||||
Atomic32 new_value) { |
||||
__asm__ __volatile__("xchgl %1,%0" // The lock prefix is implicit for xchg.
|
||||
: "=r" (new_value) |
||||
: "m" (*ptr), "0" (new_value) |
||||
: "memory"); |
||||
return new_value; // Now it's the previous value.
|
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
Atomic32 temp = increment; |
||||
__asm__ __volatile__("lock; xaddl %0,%1" |
||||
: "+r" (temp), "+m" (*ptr) |
||||
: : "memory"); |
||||
// temp now holds the old value of *ptr
|
||||
return temp + increment; |
||||
} |
||||
|
||||
inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
Atomic32 temp = increment; |
||||
__asm__ __volatile__("lock; xaddl %0,%1" |
||||
: "+r" (temp), "+m" (*ptr) |
||||
: : "memory"); |
||||
// temp now holds the old value of *ptr
|
||||
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
||||
__asm__ __volatile__("lfence" : : : "memory"); |
||||
} |
||||
return temp + increment; |
||||
} |
||||
|
||||
inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
||||
__asm__ __volatile__("lfence" : : : "memory"); |
||||
} |
||||
return x; |
||||
} |
||||
|
||||
inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
#if defined(__x86_64__) |
||||
|
||||
// 64-bit implementations of memory barrier can be simpler, because it
|
||||
// "mfence" is guaranteed to exist.
|
||||
inline void MemoryBarrier() { |
||||
__asm__ __volatile__("mfence" : : : "memory"); |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
#else |
||||
|
||||
inline void MemoryBarrier() { |
||||
if (AtomicOps_Internalx86CPUFeatures.has_sse2) { |
||||
__asm__ __volatile__("mfence" : : : "memory"); |
||||
} else { // mfence is faster but not present on PIII
|
||||
Atomic32 x = 0; |
||||
NoBarrier_AtomicExchange(&x, 0); // acts as a barrier on PIII
|
||||
} |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
if (AtomicOps_Internalx86CPUFeatures.has_sse2) { |
||||
*ptr = value; |
||||
__asm__ __volatile__("mfence" : : : "memory"); |
||||
} else { |
||||
NoBarrier_AtomicExchange(ptr, value); |
||||
// acts as a barrier on PIII
|
||||
} |
||||
} |
||||
#endif |
||||
|
||||
inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
*ptr = value; // An x86 store acts as a release barrier.
|
||||
// See comments in Atomic64 version of Release_Store(), below.
|
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { |
||||
Atomic32 value = *ptr; // An x86 load acts as a acquire barrier.
|
||||
// See comments in Atomic64 version of Release_Store(), below.
|
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic32 Release_Load(volatile const Atomic32* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
#if defined(__x86_64__) |
||||
|
||||
// 64-bit low-level operations on 64-bit platform.
|
||||
|
||||
inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
Atomic64 prev; |
||||
__asm__ __volatile__("lock; cmpxchgq %1,%2" |
||||
: "=a" (prev) |
||||
: "q" (new_value), "m" (*ptr), "0" (old_value) |
||||
: "memory"); |
||||
return prev; |
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, |
||||
Atomic64 new_value) { |
||||
__asm__ __volatile__("xchgq %1,%0" // The lock prefix is implicit for xchg.
|
||||
: "=r" (new_value) |
||||
: "m" (*ptr), "0" (new_value) |
||||
: "memory"); |
||||
return new_value; // Now it's the previous value.
|
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
Atomic64 temp = increment; |
||||
__asm__ __volatile__("lock; xaddq %0,%1" |
||||
: "+r" (temp), "+m" (*ptr) |
||||
: : "memory"); |
||||
// temp now contains the previous value of *ptr
|
||||
return temp + increment; |
||||
} |
||||
|
||||
inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
Atomic64 temp = increment; |
||||
__asm__ __volatile__("lock; xaddq %0,%1" |
||||
: "+r" (temp), "+m" (*ptr) |
||||
: : "memory"); |
||||
// temp now contains the previous value of *ptr
|
||||
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
||||
__asm__ __volatile__("lfence" : : : "memory"); |
||||
} |
||||
return temp + increment; |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
|
||||
*ptr = value; // An x86 store acts as a release barrier
|
||||
// for current AMD/Intel chips as of Jan 2008.
|
||||
// See also Acquire_Load(), below.
|
||||
|
||||
// When new chips come out, check:
|
||||
// IA-32 Intel Architecture Software Developer's Manual, Volume 3:
|
||||
// System Programming Guide, Chatper 7: Multiple-processor management,
|
||||
// Section 7.2, Memory Ordering.
|
||||
// Last seen at:
|
||||
// http://developer.intel.com/design/pentium4/manuals/index_new.htm
|
||||
//
|
||||
// x86 stores/loads fail to act as barriers for a few instructions (clflush
|
||||
// maskmovdqu maskmovq movntdq movnti movntpd movntps movntq) but these are
|
||||
// not generated by the compiler, and are rare. Users of these instructions
|
||||
// need to know about cache behaviour in any case since all of these involve
|
||||
// either flushing cache lines or non-temporal cache hints.
|
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { |
||||
Atomic64 value = *ptr; // An x86 load acts as a acquire barrier,
|
||||
// for current AMD/Intel chips as of Jan 2008.
|
||||
// See also Release_Store(), above.
|
||||
ATOMICOPS_COMPILER_BARRIER(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic64 Release_Load(volatile const Atomic64* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
Atomic64 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) { |
||||
__asm__ __volatile__("lfence" : : : "memory"); |
||||
} |
||||
return x; |
||||
} |
||||
|
||||
inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
#endif // defined(__x86_64__)
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#undef ATOMICOPS_COMPILER_BARRIER |
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_
|
||||
@ -0,0 +1,304 @@ |
||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This file is an internal atomic implementation, use atomicops.h instead.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MACOSX_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MACOSX_H_ |
||||
|
||||
#include <libkern/OSAtomic.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap32(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, |
||||
Atomic32 new_value) { |
||||
Atomic32 old_value; |
||||
do { |
||||
old_value = *ptr; |
||||
} while (!OSAtomicCompareAndSwap32(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))); |
||||
return old_value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
return OSAtomicAdd32(increment, const_cast<Atomic32*>(ptr)); |
||||
} |
||||
|
||||
inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr)); |
||||
} |
||||
|
||||
inline void MemoryBarrier() { |
||||
OSMemoryBarrier(); |
||||
} |
||||
|
||||
inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
Atomic32 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap32Barrier(old_value, new_value, |
||||
const_cast<Atomic32*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
return Acquire_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
MemoryBarrier(); |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { |
||||
Atomic32 value = *ptr; |
||||
MemoryBarrier(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic32 Release_Load(volatile const Atomic32* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
#ifdef __LP64__ |
||||
|
||||
// 64-bit implementation on 64-bit platform
|
||||
|
||||
inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
Atomic64 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap64(old_value, new_value, |
||||
const_cast<Atomic64*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, |
||||
Atomic64 new_value) { |
||||
Atomic64 old_value; |
||||
do { |
||||
old_value = *ptr; |
||||
} while (!OSAtomicCompareAndSwap64(old_value, new_value, |
||||
const_cast<Atomic64*>(ptr))); |
||||
return old_value; |
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
return OSAtomicAdd64(increment, const_cast<Atomic64*>(ptr)); |
||||
} |
||||
|
||||
inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
return OSAtomicAdd64Barrier(increment, const_cast<Atomic64*>(ptr)); |
||||
} |
||||
|
||||
inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
Atomic64 prev_value; |
||||
do { |
||||
if (OSAtomicCompareAndSwap64Barrier(old_value, new_value, |
||||
const_cast<Atomic64*>(ptr))) { |
||||
return old_value; |
||||
} |
||||
prev_value = *ptr; |
||||
} while (prev_value == old_value); |
||||
return prev_value; |
||||
} |
||||
|
||||
inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
// The lib kern interface does not distinguish between
|
||||
// Acquire and Release memory barriers; they are equivalent.
|
||||
return Acquire_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; |
||||
MemoryBarrier(); |
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
MemoryBarrier(); |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { |
||||
Atomic64 value = *ptr; |
||||
MemoryBarrier(); |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic64 Release_Load(volatile const Atomic64* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
#endif // defined(__LP64__)
|
||||
|
||||
// MacOS uses long for intptr_t, AtomicWord and Atomic32 are always different
|
||||
// on the Mac, even when they are the same size. We need to explicitly cast
|
||||
// from AtomicWord to Atomic32/64 to implement the AtomicWord interface.
|
||||
#ifdef __LP64__ |
||||
#define AtomicWordCastType Atomic64 |
||||
#else |
||||
#define AtomicWordCastType Atomic32 |
||||
#endif |
||||
|
||||
inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr, |
||||
AtomicWord old_value, |
||||
AtomicWord new_value) { |
||||
return NoBarrier_CompareAndSwap( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), |
||||
old_value, new_value); |
||||
} |
||||
|
||||
inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr, |
||||
AtomicWord new_value) { |
||||
return NoBarrier_AtomicExchange( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), new_value); |
||||
} |
||||
|
||||
inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr, |
||||
AtomicWord increment) { |
||||
return NoBarrier_AtomicIncrement( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), increment); |
||||
} |
||||
|
||||
inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr, |
||||
AtomicWord increment) { |
||||
return Barrier_AtomicIncrement( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), increment); |
||||
} |
||||
|
||||
inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr, |
||||
AtomicWord old_value, |
||||
AtomicWord new_value) { |
||||
return v8::internal::Acquire_CompareAndSwap( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), |
||||
old_value, new_value); |
||||
} |
||||
|
||||
inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr, |
||||
AtomicWord old_value, |
||||
AtomicWord new_value) { |
||||
return v8::internal::Release_CompareAndSwap( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), |
||||
old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile AtomicWord* ptr, AtomicWord value) { |
||||
NoBarrier_Store( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) { |
||||
return v8::internal::Acquire_Store( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); |
||||
} |
||||
|
||||
inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) { |
||||
return v8::internal::Release_Store( |
||||
reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); |
||||
} |
||||
|
||||
inline AtomicWord NoBarrier_Load(volatile const AtomicWord* ptr) { |
||||
return NoBarrier_Load( |
||||
reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); |
||||
} |
||||
|
||||
inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) { |
||||
return v8::internal::Acquire_Load( |
||||
reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); |
||||
} |
||||
|
||||
inline AtomicWord Release_Load(volatile const AtomicWord* ptr) { |
||||
return v8::internal::Release_Load( |
||||
reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); |
||||
} |
||||
|
||||
#undef AtomicWordCastType |
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MACOSX_H_
|
||||
@ -0,0 +1,106 @@ |
||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// The compilation of extension_set.cc fails when windows.h is included.
|
||||
// Therefore we move the code depending on windows.h to this separate cc file.
|
||||
|
||||
// Don't compile this file for people not concerned about thread safety.
|
||||
#ifndef GOOGLE_PROTOBUF_NO_THREADSAFETY |
||||
|
||||
#include <google/protobuf/stubs/atomicops.h> |
||||
|
||||
#include <windows.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
inline void MemoryBarrier() { |
||||
// We use MemoryBarrier from WinNT.h
|
||||
::MemoryBarrier(); |
||||
} |
||||
|
||||
Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
LONG result = InterlockedCompareExchange( |
||||
reinterpret_cast<volatile LONG*>(ptr), |
||||
static_cast<LONG>(new_value), |
||||
static_cast<LONG>(old_value)); |
||||
return static_cast<Atomic32>(result); |
||||
} |
||||
|
||||
Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, |
||||
Atomic32 new_value) { |
||||
LONG result = InterlockedExchange( |
||||
reinterpret_cast<volatile LONG*>(ptr), |
||||
static_cast<LONG>(new_value)); |
||||
return static_cast<Atomic32>(result); |
||||
} |
||||
|
||||
Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
return InterlockedExchangeAdd( |
||||
reinterpret_cast<volatile LONG*>(ptr), |
||||
static_cast<LONG>(increment)) + increment; |
||||
} |
||||
|
||||
#if defined(_WIN64) |
||||
|
||||
// 64-bit low-level operations on 64-bit platform.
|
||||
|
||||
Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
PVOID result = InterlockedCompareExchangePointer( |
||||
reinterpret_cast<volatile PVOID*>(ptr), |
||||
reinterpret_cast<PVOID>(new_value), reinterpret_cast<PVOID>(old_value)); |
||||
return reinterpret_cast<Atomic64>(result); |
||||
} |
||||
|
||||
Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, |
||||
Atomic64 new_value) { |
||||
PVOID result = InterlockedExchangePointer( |
||||
reinterpret_cast<volatile PVOID*>(ptr), |
||||
reinterpret_cast<PVOID>(new_value)); |
||||
return reinterpret_cast<Atomic64>(result); |
||||
} |
||||
|
||||
Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
return InterlockedExchangeAdd64( |
||||
reinterpret_cast<volatile LONGLONG*>(ptr), |
||||
static_cast<LONGLONG>(increment)) + increment; |
||||
} |
||||
|
||||
#endif // defined(_WIN64)
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_NO_THREADSAFETY
|
||||
@ -0,0 +1,147 @@ |
||||
// Copyright 2010 the V8 project authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// This file is an internal atomic implementation, use atomicops.h instead.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MSVC_H_ |
||||
#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MSVC_H_ |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace internal { |
||||
|
||||
inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, |
||||
Atomic32 increment) { |
||||
return Barrier_AtomicIncrement(ptr, increment); |
||||
} |
||||
|
||||
#if !(defined(_MSC_VER) && _MSC_VER >= 1400) |
||||
#error "We require at least vs2005 for MemoryBarrier" |
||||
#endif |
||||
|
||||
inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
||||
Atomic32 old_value, |
||||
Atomic32 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
NoBarrier_AtomicExchange(ptr, value); |
||||
// acts as a barrier in this implementation
|
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { |
||||
*ptr = value; // works w/o barrier for current Intel chips as of June 2005
|
||||
// See comments in Atomic64 version of Release_Store() below.
|
||||
} |
||||
|
||||
inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { |
||||
Atomic32 value = *ptr; |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic32 Release_Load(volatile const Atomic32* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
#if defined(_WIN64) |
||||
|
||||
// 64-bit low-level operations on 64-bit platform.
|
||||
|
||||
inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, |
||||
Atomic64 increment) { |
||||
return Barrier_AtomicIncrement(ptr, increment); |
||||
} |
||||
|
||||
inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; |
||||
} |
||||
|
||||
inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
NoBarrier_AtomicExchange(ptr, value); |
||||
// acts as a barrier in this implementation
|
||||
} |
||||
|
||||
inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { |
||||
*ptr = value; // works w/o barrier for current Intel chips as of June 2005
|
||||
|
||||
// When new chips come out, check:
|
||||
// IA-32 Intel Architecture Software Developer's Manual, Volume 3:
|
||||
// System Programming Guide, Chatper 7: Multiple-processor management,
|
||||
// Section 7.2, Memory Ordering.
|
||||
// Last seen at:
|
||||
// http://developer.intel.com/design/pentium4/manuals/index_new.htm
|
||||
} |
||||
|
||||
inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { |
||||
Atomic64 value = *ptr; |
||||
return value; |
||||
} |
||||
|
||||
inline Atomic64 Release_Load(volatile const Atomic64* ptr) { |
||||
MemoryBarrier(); |
||||
return *ptr; |
||||
} |
||||
|
||||
inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, |
||||
Atomic64 old_value, |
||||
Atomic64 new_value) { |
||||
return NoBarrier_CompareAndSwap(ptr, old_value, new_value); |
||||
} |
||||
|
||||
#endif // defined(_WIN64)
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MSVC_H_
|
||||
@ -0,0 +1,122 @@ |
||||
// Copyright 2011 the V8 authors. All rights reserved.
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following
|
||||
// disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_PLATFORM_MACROS_H_ |
||||
#define GOOGLE_PROTOBUF_PLATFORM_MACROS_H_ |
||||
|
||||
#include <google/protobuf/stubs/common.h> |
||||
|
||||
// Processor architecture detection. For more info on what's defined, see:
|
||||
// http://msdn.microsoft.com/en-us/library/b0084kay.aspx
|
||||
// http://www.agner.org/optimize/calling_conventions.pdf
|
||||
// or with gcc, run: "echo | gcc -E -dM -"
|
||||
#if defined(_M_X64) || defined(__x86_64__) |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_X64 1 |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_64_BIT 1 |
||||
#define GOOGLE_PROTOBUF_HOST_CAN_READ_UNALIGNED 1 |
||||
#elif defined(_M_IX86) || defined(__i386__) |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_IA32 1 |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_32_BIT 1 |
||||
#define GOOGLE_PROTOBUF_HOST_CAN_READ_UNALIGNED 1 |
||||
#elif defined(__ARMEL__) |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_ARM 1 |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_32_BIT 1 |
||||
// Some CPU-OS combinations allow unaligned access on ARM. We assume
|
||||
// that unaligned accesses are not allowed unless the build system
|
||||
// defines the CAN_USE_UNALIGNED_ACCESSES macro to be non-zero.
|
||||
#if CAN_USE_UNALIGNED_ACCESSES |
||||
#define GOOGLE_PROTOBUF_HOST_CAN_READ_UNALIGNED 1 |
||||
#endif |
||||
#elif defined(__MIPSEL__) |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_MIPS 1 |
||||
#define GOOGLE_PROTOBUF_HOST_ARCH_32_BIT 1 |
||||
#else |
||||
#error Host architecture was not detected as supported by v8 |
||||
#endif |
||||
|
||||
// Target architecture detection. This may be set externally. If not, detect
|
||||
// in the same way as the host architecture, that is, target the native
|
||||
// environment as presented by the compiler.
|
||||
#if !defined(GOOGLE_PROTOBUF_TARGET_ARCH_X64) && \ |
||||
!defined(GOOGLE_PROTOBUF_TARGET_ARCH_IA32) && \
|
||||
!defined(GOOGLE_PROTOBUF_TARGET_ARCH_ARM) && \
|
||||
!defined(GOOGLE_PROTOBUF_TARGET_ARCH_MIPS) |
||||
#if defined(_M_X64) || defined(__x86_64__) |
||||
#define GOOGLE_PROTOBUF_TARGET_ARCH_X64 1 |
||||
#elif defined(_M_IX86) || defined(__i386__) |
||||
#define GOOGLE_PROTOBUF_TARGET_ARCH_IA32 1 |
||||
#elif defined(__ARMEL__) |
||||
#define GOOGLE_PROTOBUF_TARGET_ARCH_ARM 1 |
||||
#elif defined(__MIPSEL__) |
||||
#define GOOGLE_PROTOBUF_TARGET_ARCH_MIPS 1 |
||||
#else |
||||
#error Target architecture was not detected as supported by v8 |
||||
#endif |
||||
#endif |
||||
|
||||
// Check for supported combinations of host and target architectures.
|
||||
#if defined(GOOGLE_PROTOBUF_TARGET_ARCH_IA32) && \ |
||||
!defined(GOOGLE_PROTOBUF_HOST_ARCH_IA32) |
||||
#error Target architecture ia32 is only supported on ia32 host |
||||
#endif |
||||
#if defined(GOOGLE_PROTOBUF_TARGET_ARCH_X64) && \ |
||||
!defined(GOOGLE_PROTOBUF_HOST_ARCH_X64) |
||||
#error Target architecture x64 is only supported on x64 host |
||||
#endif |
||||
#if (defined(GOOGLE_PROTOBUF_TARGET_ARCH_ARM) && \ |
||||
!(defined(GOOGLE_PROTOBUF_HOST_ARCH_IA32) || \
|
||||
defined(GOOGLE_PROTOBUF_HOST_ARCH_ARM))) |
||||
#error Target architecture arm is only supported on arm and ia32 host |
||||
#endif |
||||
#if (defined(GOOGLE_PROTOBUF_TARGET_ARCH_MIPS) && \ |
||||
!(defined(GOOGLE_PROTOBUF_HOST_ARCH_IA32) || \
|
||||
defined(GOOGLE_PROTOBUF_HOST_ARCH_MIPS))) |
||||
#error Target architecture mips is only supported on mips and ia32 host |
||||
#endif |
||||
|
||||
// Define unaligned read for the target architectures supporting it.
|
||||
#if defined(GOOGLE_PROTOBUF_TARGET_ARCH_X64) || \ |
||||
defined(GOOGLE_PROTOBUF_TARGET_ARCH_IA32) |
||||
#define GOOGLE_PROTOBUF_TARGET_CAN_READ_UNALIGNED 1 |
||||
#elif GOOGLE_PROTOBUF_TARGET_ARCH_ARM |
||||
// Some CPU-OS combinations allow unaligned access on ARM. We assume
|
||||
// that unaligned accesses are not allowed unless the build system
|
||||
// defines the CAN_USE_UNALIGNED_ACCESSES macro to be non-zero.
|
||||
#if CAN_USE_UNALIGNED_ACCESSES |
||||
#define GOOGLE_PROTOBUF_TARGET_CAN_READ_UNALIGNED 1 |
||||
#endif |
||||
#elif GOOGLE_PROTOBUF_TARGET_ARCH_MIPS |
||||
#else |
||||
#error Target architecture is not supported by v8 |
||||
#endif |
||||
|
||||
#if (defined(__APPLE__) && defined(__MACH__)) || \ |
||||
defined(__FreeBSD__) || defined(__OpenBSD__) |
||||
#define GOOGLE_PROTOBUF_USING_BSD_ABI |
||||
#endif |
||||
|
||||
#endif // GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
|
||||
Loading…
Reference in new issue