opentelemetry中spin_lock_mutex.h中的实现：

    1. // Copyright The OpenTelemetry Authors
    2. // SPDX-License-Identifier: Apache-2.0
    4. #pragma once
    6. #include <atomic>
    7. #include <chrono>
    8. #include <thread>
    10. #include "opentelemetry/version.h"
    12. #if defined(_MSC_VER)
    13. #  ifndef NOMINMAX
    14. #    define NOMINMAX
    15. #  endif
    16. #  define _WINSOCKAPI_  // stops including winsock.h
    17. #  include <windows.h>
    18. #elif defined(__i386__) || defined(__x86_64__)
    19. #  if defined(__clang__)
    20. #    include <emmintrin.h>
    21. #  endif
    22. #endif
    24. OPENTELEMETRY_BEGIN_NAMESPACE
    25. namespace common
    26. {
    28. constexpr int SPINLOCK_FAST_ITERATIONS = 100;
    29. constexpr int SPINLOCK_SLEEP_MS        = 1;
    31. /**
    32.  * A Mutex which uses atomic flags and spin-locks instead of halting threads.
    33.  *
    34.  * This mutex uses an incremental back-off strategy with the following phases:
    35.  * 1. A tight spin-lock loop (pending: using hardware PAUSE/YIELD instructions)
    36.  * 2. A loop where the current thread yields control after checking the lock.
    37.  * 3. Issuing a thread-sleep call before starting back in phase 1.
    38.  *
    39.  * This is meant to give a good balance of perofrmance and CPU consumption in
    40.  * practice.
    41.  *
    42.  * This mutex uses an incremental back-off strategy with the following phases:
    43.  * 1. A tight spin-lock loop (pending: using hardware PAUSE/YIELD instructions)
    44.  * 2. A loop where the current thread yields control after checking the lock.
    45.  * 3. Issuing a thread-sleep call before starting back in phase 1.
    46.  *
    47.  * This is meant to give a good balance of perofrmance and CPU consumption in
    48.  * practice.
    49.  *
    50.  * This class implements the `BasicLockable` specification:
    51.  * https://en.cppreference.com/w/cpp/named_req/BasicLockable
    52.  */
    53. class SpinLockMutex
    54. {
    55. public:
    56.   SpinLockMutex() noexcept {}
    57.   ~SpinLockMutex() noexcept            = default;
    58.   SpinLockMutex(const SpinLockMutex &) = delete;
    59.   SpinLockMutex &operator=(const SpinLockMutex &) = delete;
    60.   SpinLockMutex &operator=(const SpinLockMutex &) volatile = delete;
    62.   /**
    63.    * Attempts to lock the mutex.  Return immediately with `true` (success) or `false` (failure).
    64.    */
    65.   bool try_lock() noexcept
    66.   {
    67.     return !flag_.load(std::memory_order_relaxed) &&
    68.            !flag_.exchange(true, std::memory_order_acquire);
    69.   }
    71.   /**
    72.    * Blocks until a lock can be obtained for the current thread.
    73.    *
    74.    * This mutex will spin the current CPU waiting for the lock to be available.  This can have
    75.    * decent performance in scenarios where there is low lock contention and lock-holders achieve
    76.    * their work quickly.  It degrades in scenarios where locked tasks take a long time.
    77.    */
    78.   void lock() noexcept
    79.   {
    80.     for (;;)
    81.     {
    82.       // Try once
    83.       if (!flag_.exchange(true, std::memory_order_acquire))
    84.       {
    85.         return;
    86.       }
    87.       // Spin-Fast (goal ~10ns)
    88.       for (std::size_t i = 0; i < SPINLOCK_FAST_ITERATIONS; ++i)
    89.       {
    90.         if (try_lock())
    91.         {
    92.           return;
    93.         }
    94. // Issue a Pause/Yield instruction while spinning.
    95. #if defined(_MSC_VER)
    96.         YieldProcessor();
    97. #elif defined(__i386__) || defined(__x86_64__)
    98. #  if defined(__clang__)
    99.         _mm_pause();
    100. #  else
    101.         __builtin_ia32_pause();
    102. #  endif
    103. #elif defined(__arm__)
    104.         // This intrinsic should fail to be found if YIELD is not supported on the current
    105.         // processor.
    106.         // __yield();
    107.         asm volatile("yield");
    108. #else
    109.         // TODO: Issue PAGE/YIELD on other architectures.
    110. #endif
    111.       }
    112.       // Yield then try again (goal ~100ns)
    113.       std::this_thread::yield();
    114.       if (try_lock())
    115.       {
    116.         return;
    117.       }
    118.       // Sleep and then start the whole process again. (goal ~1000ns)
    119.       std::this_thread::sleep_for(std::chrono::milliseconds(SPINLOCK_SLEEP_MS));
    120.     }
    121.     return;
    122.   }
    123.   /** Releases the lock held by the execution agent. Throws no exceptions. */
    124.   void unlock() noexcept { flag_.store(false, std::memory_order_release); }
    126. private:
    127.   std::atomic<bool> flag_{false};
    128. };
    130. }  // namespace common
    131. OPENTELEMETRY_END_NAMESPACE

    编译问题：使用ninja+Ubuntu+clang编译 android arm时找不到__yield。
    找到腾讯云加社区解答：
    __yield内部函数被指定为ARM C Language Extensions的一部分(参见8.4“提示”)。它发出yield instruction这大致相当于x86 pause。它正是为等待自旋锁这样的情况而设计的；它可以防止CPU过度冲击高速缓存线(这会损害性能)，可能会节省一些电量，并且在使用超线程CPU的情况下，会使更多的计算单元可供其他逻辑处理器使用。
    (请注意，它纯粹是一个CPU函数，而不是操作系统或库调用；它不会像类似名称的pause()、sched_yield()或std::this_thread::yield()调用那样为操作系统生成CPU时间片。)
    尽管GCC支持一些ACLE内部函数，但它似乎缺少这个函数。您应该能够替换为asm volatile(“yield”);。yield指令没有体系结构效果(它像nop一样执行)，因此不需要寄存器或内存占位器。