nginx atomic x86

最新推荐文章于 2025-02-11 17:23:28 发布
最新推荐文章于 2025-02-11 17:23:28 发布
阅读量2.1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： nginx 文章标签： x86 nginx compiler gcc sun perl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hintonic/article/details/7211339


/*
 * Copyright (C) Igor Sysoev
 */




#ifndef _NGX_ATOMIC_H_INCLUDED_
#define _NGX_ATOMIC_H_INCLUDED_




#include <ngx_config.h>
#include <ngx_core.h>




#if (NGX_HAVE_LIBATOMIC)


#define AO_REQUIRE_CAS
#include <atomic_ops.h>


#define NGX_HAVE_ATOMIC_OPS  1


typedef long                        ngx_atomic_int_t;
typedef AO_t                        ngx_atomic_uint_t;
typedef volatile ngx_atomic_uint_t  ngx_atomic_t;


#if (NGX_PTR_SIZE == 8)
#define NGX_ATOMIC_T_LEN            (sizeof("-9223372036854775808") - 1)
#else
#define NGX_ATOMIC_T_LEN            (sizeof("-2147483648") - 1)
#endif


#define ngx_atomic_cmp_set(lock, old, new)                                    \
    AO_compare_and_swap(lock, old, new)
#define ngx_atomic_fetch_add(value, add)                                      \
    AO_fetch_and_add(value, add)
#define ngx_memory_barrier()        AO_nop()
#define ngx_cpu_pause()




#elif (NGX_DARWIN_ATOMIC)


/*
 * use Darwin 8 atomic(3) and barrier(3) operations
 * optimized at run-time for UP and SMP
 */


#include <libkern/OSAtomic.h>


/* "bool" conflicts with perl's CORE/handy.h */
#undef bool




#define NGX_HAVE_ATOMIC_OPS  1


#if (NGX_PTR_SIZE == 8)


typedef int64_t                     ngx_atomic_int_t;
typedef uint64_t                    ngx_atomic_uint_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-9223372036854775808") - 1)


#define ngx_atomic_cmp_set(lock, old, new)                                    \
    OSAtomicCompareAndSwap64Barrier(old, new, (int64_t *) lock)


#define ngx_atomic_fetch_add(value, add)                                      \
    (OSAtomicAdd64(add, (int64_t *) value) - add)


#else


typedef int32_t                     ngx_atomic_int_t;
typedef uint32_t                    ngx_atomic_uint_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-2147483648") - 1)


#define ngx_atomic_cmp_set(lock, old, new)                                    \
    OSAtomicCompareAndSwap32Barrier(old, new, (int32_t *) lock)


#define ngx_atomic_fetch_add(value, add)                                      \
    (OSAtomicAdd32(add, (int32_t *) value) - add)


#endif


#define ngx_memory_barrier()        OSMemoryBarrier()


#define ngx_cpu_pause()


typedef volatile ngx_atomic_uint_t  ngx_atomic_t;




#elif (NGX_HAVE_GCC_ATOMIC)


/* GCC 4.1 builtin atomic operations */


#define NGX_HAVE_ATOMIC_OPS  1


typedef long                        ngx_atomic_int_t;
typedef unsigned long               ngx_atomic_uint_t;


#if (NGX_PTR_SIZE == 8)
#define NGX_ATOMIC_T_LEN            (sizeof("-9223372036854775808") - 1)
#else
#define NGX_ATOMIC_T_LEN            (sizeof("-2147483648") - 1)
#endif


typedef volatile ngx_atomic_uint_t  ngx_atomic_t;




#define ngx_atomic_cmp_set(lock, old, set)                                    \
    __sync_bool_compare_and_swap(lock, old, set)


#define ngx_atomic_fetch_add(value, add)                                      \
    __sync_fetch_and_add(value, add)


#define ngx_memory_barrier()        __sync_synchronize()


#if ( __i386__ || __i386 || __amd64__ || __amd64 )
#define ngx_cpu_pause()             __asm__ ("pause")
#else
#define ngx_cpu_pause()
#endif




#elif ( __i386__ || __i386 )


typedef int32_t                     ngx_atomic_int_t;
typedef uint32_t                    ngx_atomic_uint_t;
typedef volatile ngx_atomic_uint_t  ngx_atomic_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-2147483648") - 1)




#if ( __SUNPRO_C )


#define NGX_HAVE_ATOMIC_OPS  1


ngx_atomic_uint_t
ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
    ngx_atomic_uint_t set);


ngx_atomic_int_t
ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add);


/*
 * Sun Studio 12 exits with segmentation fault on '__asm ("pause")',
 * so ngx_cpu_pause is declared in src/os/unix/ngx_sunpro_x86.il
 */


void
ngx_cpu_pause(void);


/* the code in src/os/unix/ngx_sunpro_x86.il */


#define ngx_memory_barrier()        __asm (".volatile"); __asm (".nonvolatile")




#else /* ( __GNUC__ || __INTEL_COMPILER ) */


#define NGX_HAVE_ATOMIC_OPS  1


#include "ngx_gcc_atomic_x86.h"


#endif




#elif ( __amd64__ || __amd64 )


typedef int64_t                     ngx_atomic_int_t;
typedef uint64_t                    ngx_atomic_uint_t;
typedef volatile ngx_atomic_uint_t  ngx_atomic_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-9223372036854775808") - 1)




#if ( __SUNPRO_C )


#define NGX_HAVE_ATOMIC_OPS  1


ngx_atomic_uint_t
ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
    ngx_atomic_uint_t set);


ngx_atomic_int_t
ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add);


/*
 * Sun Studio 12 exits with segmentation fault on '__asm ("pause")',
 * so ngx_cpu_pause is declared in src/os/unix/ngx_sunpro_amd64.il
 */


void
ngx_cpu_pause(void);


/* the code in src/os/unix/ngx_sunpro_amd64.il */


#define ngx_memory_barrier()        __asm (".volatile"); __asm (".nonvolatile")




#else /* ( __GNUC__ || __INTEL_COMPILER ) */


#define NGX_HAVE_ATOMIC_OPS  1


#include "ngx_gcc_atomic_amd64.h"


#endif




#elif ( __sparc__ || __sparc || __sparcv9 )


#if (NGX_PTR_SIZE == 8)


typedef int64_t                     ngx_atomic_int_t;
typedef uint64_t                    ngx_atomic_uint_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-9223372036854775808") - 1)


#else


typedef int32_t                     ngx_atomic_int_t;
typedef uint32_t                    ngx_atomic_uint_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-2147483648") - 1)


#endif


typedef volatile ngx_atomic_uint_t  ngx_atomic_t;




#if ( __SUNPRO_C )


#define NGX_HAVE_ATOMIC_OPS  1


#include "ngx_sunpro_atomic_sparc64.h"




#else /* ( __GNUC__ || __INTEL_COMPILER ) */


#define NGX_HAVE_ATOMIC_OPS  1


#include "ngx_gcc_atomic_sparc64.h"


#endif




#elif ( __powerpc__ || __POWERPC__ )


#define NGX_HAVE_ATOMIC_OPS  1


#if (NGX_PTR_SIZE == 8)


typedef int64_t                     ngx_atomic_int_t;
typedef uint64_t                    ngx_atomic_uint_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-9223372036854775808") - 1)


#else


typedef int32_t                     ngx_atomic_int_t;
typedef uint32_t                    ngx_atomic_uint_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-2147483648") - 1)


#endif


typedef volatile ngx_atomic_uint_t  ngx_atomic_t;




#include "ngx_gcc_atomic_ppc.h"


#endif




#if !(NGX_HAVE_ATOMIC_OPS)


#define NGX_HAVE_ATOMIC_OPS  0


typedef int32_t                     ngx_atomic_int_t;
typedef uint32_t                    ngx_atomic_uint_t;
typedef volatile ngx_atomic_uint_t  ngx_atomic_t;
#define NGX_ATOMIC_T_LEN            (sizeof("-2147483648") - 1)




static ngx_inline ngx_atomic_uint_t
ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
     ngx_atomic_uint_t set)
{
     if (*lock == old) {
         *lock = set;
         return 1;
     }


     return 0;
}




static ngx_inline ngx_atomic_int_t
ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
{
     ngx_atomic_int_t  old;


     old = *value;
     *value += add;


     return old;
}


#define ngx_memory_barrier()
#define ngx_cpu_pause()


#endif




void ngx_spinlock(ngx_atomic_t *lock, ngx_atomic_int_t value, ngx_uint_t spin);


#define ngx_trylock(lock)  (*(lock) == 0 && ngx_atomic_cmp_set(lock, 0, 1))
#define ngx_unlock(lock)    *(lock) = 0

#endif /* _NGX_ATOMIC_H_INCLUDED_ */





/*
 * Copyright (C) Igor Sysoev
 */




#if (NGX_SMP)
#define NGX_SMP_LOCK  "lock;"
#else
#define NGX_SMP_LOCK
#endif




/*
 * "cmpxchgl  r, [m]":
 *
 *     if (eax == [m]) {
 *         zf = 1;
 *         [m] = r;
 *     } else {
 *         zf = 0;
 *         eax = [m];
 *     }
 *
 *
 * The "r" means the general register.
 * The "=a" and "a" are the %eax register.
 * Although we can return result in any register, we use "a" because it is
 * used in cmpxchgl anyway.  The result is actually in %al but not in %eax,
 * however, as the code is inlined gcc can test %al as well as %eax,
 * and icc adds "movzbl %al, %eax" by itself.
 *
 * The "cc" means that flags were changed.


 
int cmpxchgl(fjutex, old, new)
{
        __asm__ __volatile__(LOCK_PREFIX "cmpxchgl %k1,%2"
                     : "=a"(futex)
                     : "q"(new), "m"(*__xg(ptr)), "0"(old)
                     : "memory");


}
等价为：
eax = old;
if (futex == old) {
   futex = new;
   return old;
} else {
   return futex;
}
锁操作：
cmpxchgl(futex, 0, 1);
如果futex没有加锁，那么对futex置1，并返回0表示原来没有加锁；
如果futex已经被加锁，那么返回1表示原来已经加锁了；
libc里会判断返回值：
如果发现futex已经被加锁，则调用futex_wait;
如果发现futex没有被加锁，则直接返回；




 */


static ngx_inline ngx_atomic_uint_t
ngx_atomic_cmp_set( ngx_atomic_t *lock, ngx_atomic_uint_t old,
    ngx_atomic_uint_t set )
{
    u_char  res;


    __asm__ volatile (


         NGX_SMP_LOCK
    "    cmpxchgl  %3, %1;   "
    "    sete      %0;       "


    : "=a" (res) : "m" (*lock), "a" (old), "r" (set) : "cc", "memory");


    return res;
}




/*
 * "xaddl  r, [m]":
 *
 *     temp = [m];
 *     [m] += r;
 *     r = temp;
 *
 *
 * The "+r" means the general register.
 * The "cc" means that flags were changed.
 */




#if !(( __GNUC__ == 2 && __GNUC_MINOR__ <= 7 ) || ( __INTEL_COMPILER >= 800 ))


/*
 * icc 8.1 and 9.0 compile broken code with -march=pentium4 option:
 * ngx_atomic_fetch_add() always return the input "add" value,
 * so we use the gcc 2.7 version.
 *
 * icc 8.1 and 9.0 with -march=pentiumpro option or icc 7.1 compile
 * correct code.
 */


static ngx_inline ngx_atomic_int_t
ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
{
    __asm__ volatile (


         NGX_SMP_LOCK
    "    xaddl  %0, %1;   "


    : "+r" (add) : "m" (*value) : "cc", "memory");


    return add;
}




#else


/*
 * gcc 2.7 does not support "+r", so we have to use the fixed
 * %eax ("=a" and "a") and this adds two superfluous instructions in the end
 * of code, something like this: "mov %eax, %edx / mov %edx, %eax".
 */


static ngx_inline ngx_atomic_int_t
ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
{
    ngx_atomic_uint_t  old;


    __asm__ volatile (


         NGX_SMP_LOCK
    "    xaddl  %2, %1;   "


    : "=a" (old) : "m" (*value), "a" (add) : "cc", "memory");


    return old;
}


#endif




/*
 * on x86 the write operations go in a program order, so we need only
 * to disable the gcc reorder optimizations
 */


#define ngx_memory_barrier()    __asm__ volatile ("" ::: "memory")


/* old "as" does not support "pause" opcode */
#define ngx_cpu_pause()         __asm__ (".byte 0xf3, 0x90")

GCC: x86 原子操作分析
mzhan017的博客
11-07 542
从gcc的源码看，在讲atomic原子操作内置函数展开的时候，会判断目标机器是否支持线程级别的fence机制。下面我看看这个x86的实现；这里注释可以看出来，x86除了seq-cst默认指令不支持外，其他的操作模型都已默认实现，所以我们如果要实验内存模型，只有seq-cst可以看到额外的辅助指令。当然这些额外的指令其实就是intel支持的fense指令。这里有定义x86机器的同步指令的一些信息。原子操作的机制，因为它的普遍性，gcc将其抽象化，提供公共的接口，不需要程序员自己再制作一套原子操作的实现。
【Nginx学习】5大绝招揭秘：Nginx进程间通信机制之x86架构下的原子操作
java专栏
12-02 421
原子操作是指不可分割的操作，即在执行过程中不会被中断。在多进程或多线程环境中，原子操作非常重要，因为它可以防止多个进程或线程同时访问同一资源时发生数据竞争和不一致的问题。通过上述的解析，我们可以看到Nginx在x86架构下如何通过CAS、TAS和FAA等指令实现原子操作。从加载旧值、比较和交换到增加和返回，每一步都至关重要。Nginx通过这些步骤，确保了多个工作进程之间的数据同步和一致性，提高了系统的性能和稳定性。希望这次的探索之旅能够让你对Nginx的原子操作机制有了更深的理解。
NGINX原子操作
天涯角落的专栏
03-23 2905
nginx实现了一个跨平台的原子操作接口。 它分别实现了LIBATOMIC，DARWIN_ATOMIC，GCC_ATOMIC等原子操作。 LIBATOMIC是一套平台无关原子操作库。 DARWIN_ATOMIC苹果平台原子操作库。 GCC_ATOMIC GCC内置的原子操作接口。 如果实现了上述任意一种原子操作接口，则定义： #define NGX_HAVE_ATOMIC_
nginx用第三方yum源atomic安装，与mysql数据库的安装步骤。atomic只用来安装nginx。
wuapeng的博客
06-08 1130
文章来自：http://blog.sina.com.cn/s/blog_8442befd01016195.html 注意：atomic只用来安装nginx。mysql与php都是用的系统源（可以尝试163源）。   1.关闭防火墙 [root@CentOS ~]# chkconfig iptables off 2.关闭selinux vi /etc/sysconfig/selin
Nginx中的原子操作
evsqiezi
05-17 1559
原子操作在系统编程中属于基础工具。nginx与其他软件很不一样，它几乎把所有操作系统的功能都封装了一遍，估计是出于编程一致性和可移植性的考虑。对于原子操作，nginx提供一组接口。 这里我们只研究有GCC 4.1以上版本的情况，因为nginx对不同的情况有不同的实现，GCC应该还是比较普遍的吧 先看些基本类型 typedef long ngx_atomic_int_t; type
Nginx原子操作及自旋锁实现
孟凡霄
12-11 1422
Nginx原子操作 执行原子操作的变量只有整形 这两种整型都使用了volatile关键字告诉C编译器不要做优化 nginx原子操作提供的2个方法 ngx_atomic_cmp_set 入参：ngx_auomic_t*lock,ngx_atomic_unit_t old,ngx_atomic_unit set compare & set ngx_atomic_fetch_add 入参：ngx_atomic_t*value,ngx_atomic_int_t
linux部署web服务器-Nginx
qq_39665680的博客
05-25 3190
构建自己的服务器网站
Nginx基础：4:三方模块的安装与设定
知行合一 止于至善
01-29 3571
前面一篇文章介绍了三方模块的是否安装的确认方法，这篇文章继续以subs_filter为例进行介绍如何进行源码编译和设定。
Nginx：linux下安装nginx与配置
qq_36193940的博客
11-30 674
Nginx：linux下安装nginx与配置摘自 :https://www.cnblogs.com/shamo89/p/7645792.html下载解压编译安装启动停止平滑重启判断Nginx配置是否正确命令访问加了中文注解的nginx.conf 摘自 :https://www.cnblogs.com/shamo89/p/7645792.html linux系统为Centos 64位 准备目录 [r...
Ubuntu 下 nginx-1.24.0 源码分析 - ngx_atomic_cmp_set 函数
最新发布
weixin_41812346的博客
02-11 818
于是在 src\os\unix\ngx_atomic.h 中。前缀，确保在多核环境下的原子性，避免竞态条件。objs/ngx_auto_config.h 中。前缀，确保指令的原子性；设置 ZF（Zero Flag）为 1。宏定义，在多核（SMP）系统中扩展为。：告知编译器条件寄存器和内存可能被修改。所以当前环境是 x86_64。的值存入任意通用寄存器（如。宏适配不同平台（如单核无需。结果（ZF 标志位）设置。：内存操作数，直接操作。设置 ZF 为 0。
php的原子操作,Nginx中的原子操作
weixin_35261385的博客
03-28 157
在不支持原子操作的处理器上Nginx提供了自己的原子操作，但是该原子操作使用C语言模拟的：static ngx_inline ngx_atomic_uint_tngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,ngx_atomic_uint_t set){if (*lock == old) {*lock = set;retur...
libatomic_ops 项目教程
gitblog_00763的博客
10-09 520
libatomic_ops 项目教程 1. 项目介绍 libatomic_ops 是一个提供硬件原子内存更新操作的半便携式实现的开源项目。它支持多种架构，允许开发者在信号处理程序中执行更多操作，更有效地利用多处理器系统，编写无锁代码，以及探索新的线程编程范式。 该项目的主要特点包括： 半便携式实现：支持多种硬件架构，提供原子内存更新操作。 高性能：允许编写无锁代码，可能在某些情况下显著提高性能。...
【CompareAndSwap底层原理】
我是Java程序员廖志伟，感谢朋友们的支持！
06-15 385
为了避免被发现，小偷想到了一个方法：他观察了一会儿密码锁的操作，发现每次输入密码之后，密码锁会将输入的数字与一个内部的计数器相加，然后将相加的结果存储在一个内部变量中。小偷再次来到密码锁前，输入了一组错误的密码，密码锁将输入的数字与计数器相加之后，存储在了内部变量中，但是这时存储的结果已经不正确了，因为小偷已经改变了计数器的值。CompareAndSwap（CAS）是一种并发编程中的操作，它可以判断一个变量的当前值是否与预期值相同，如果相同，就将该变量的值设置为新值。在该示例中，我们使用了Java提供的。
多线程原子操作方法(atomic,compare_and_swap)
木牛的博客
08-31 2776
在前面的多处理器编程艺术文章中，谈到了lock free算法。多线程编程通常碰到的问题是很多操作的非原子性（non-atomic）。 本文通过程序实例，说明多线程中由于访问同一数据变量可能造成写丢失的情况。并通过mutex、atomic、compare_and_swap逻辑完成对于多线程的控制。1.非线程安全方式 多个线程并发地将一个变量相加n次。 volatile unsigned long counter = 0; void Add(void *arg) { int i; int iter =
nginx中锁的设计以及惊群的处理
但行好事 莫问前程
05-03 385
nginx中使用的锁是自己来实现的，这里锁的实现分为两种情况，一种是支持原子操作的情况，也就是由NGX_HAVE_ATOMIC_OPS这个宏来进行控制的，一种是不支持原子操作，这是是使用文件锁来实现。 首先我们要知道在用户空间进程间锁实现的原理，起始原理很简单，就是能弄一个让所有进程共享的东西，比如mmap的内存，比如文件，然后通过这个东西来控制进程的互斥。 说起来锁很简单，就是共享一...
19.Nginx原子操作
疯哥哥带你飞
11-08 704
Nginx定义了自己的原子类型，并实现了部分原子操作，从代码中我们可以看出，原子操作的关键在于lock汇编指令前缀(锁内存总线)。从前面的代码学习，我们可以发现Nginx的worker进程间accept互斥锁是借助于下面的原子操作ngx_atomic_cmp_set来实现的/*os/unix/ngx_atomic.h */ /* __i386__和__amd64__是编译器的预定义宏, 用于表示...
Compare-and-swap(CAS无锁算法)
Jeff_的博客
03-08 5851
锁的优缺 锁是用来做并发最简单的方式，当然其代价也是最高的。内核态的锁的时候需要操作系统进行一次上下文切换，加锁、释放锁会导致比较多的上下文切换和调度延时，等待锁的线程会被挂起直至锁释放。在上下文切换的时候，cpu之前缓存的指令和数据都将失效，对性能有很大的损失。操作系统对多线程的锁进行判断就像两姐妹在为一个玩具在争吵，然后操作系统就是能决定他们谁能拿到玩具的父母，这是很慢的。用户态的锁虽然避免了...
解密Linux内核神器：内存屏障的秘密功效与应用方法
嵌入式Linux内核的博客
06-30 614
现在大多数现代计算机为了提高性能而采取乱序执行，这可能会导致程序运行不符合我们预期，内存屏障就是一类同步屏障指令，是CPU或者编译器在对内存随机访问的操作中的一个同步点，只有在此点之前的所有读写操作都执行后才可以执行此点之后的操作。内存屏障，也称内存栅栏，内存栅障，屏障指令等， 是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作。大多数现代计算机为了提高性能而采取乱序执行，这使得内存屏障成为必须。
Nginx x86架构镜像的创建与应用
根据提供的文件信息，我们需要详细探讨与“nginx镜像-x86架构”相关的知识点。首先，我们需要明确nginx是什么，其次解释镜像的概念，再来讨论x86架构的相关知识，以及如何将nginx镜像与x86架构结合起来。 ### Nginx...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值