[精彩] 对int变量的赋值是原子操作吗?

void *incCount( int id )

{

    int i,j;



	printf( "Hello, I am pthread %d\n", id );

	for( i=0; i<1000; i++ ){

		for(j=0; j<50000;j++)

			count++;

	}



	printf( "[%d] Done.\n", id );

	return NULL;

}

int a = 10;

int b = 1;

int

main()

{

    b = a;       //赋值

    return 0;

}

movl a, %eax

movl %eax, b

ldr r3, .L2                  #取a的地址，放在r3

ldr r2, [r3, #0]          #[]操作取r3地址里的值，放在r2

ldr r3, .L2+4             #取b的地址，放在r3

str r2, [r3, #0]          #赋值

...

L2:

    .word a

    .word b

mov    a, 源第一个字节

mov    目的第一个字节, a

mov    a, 源第二个字节

mov    目的第二个字节, a

a=10;

b=a;

movl a,%eax   #1

movl %eax, b  #2

movl x, x     #3

[*]不能认为 b 的值就是 10
[*]不能认为 a 的值仍然是 10

a=10;

b=a;

movl a,%eax   #1

movl %eax, b  #2

movl x, x     #3

看atomic_t的定义，就定义为一个整数。

atomic_set()和atomic_read()就是一个赋值汇编语句。没有用lock.

int b, i;

main()

{

  ....

    pthread_create(&thread, NULL, (void *(*)(void *))incCount1, (void *)r);

    pthread_create(&thread, NULL, (void *(*)(void *))incCount2, (void *)r);

   ....

}

void *incCount1( int id )

{   

    while(1){

        i = 10;

    }

}



void *incCount2( int id )

{   

    while(1){

        i = 50;

        b = i;

        if (b!=i)

        {   

            printf("crashed\n");

            exit(1);

        }

    }

}

incCount1:

        ...

.L24:

        movl    $10, i

        jmp     .L24

        ...

incCount2:

        ...

.L28:

        movl    $50, i          #1

        movl    i, %eax       #2

        movl    %eax, b      #3

        movl    b, %eax      #4

        cmpl    i, %eax       #5

        je      .L28

        ...

void * inc_count2(int id)

{

       while(1) {

                printf("i = %d\n, i);                /*    #1     */

                printf("d = %d\n",d);             /*    #2    */





                i = 50;

                b = i;

               

                printf("i = %d\n", i);             /*    #3     */

                printf("d = %d\n",d);           /*     #4     */

                

                if (b != i) {

                         printf("crashed\n");

                         exit(1);

                }

       }

}

i = 10

b = 0

... ...



i=50

b=50

i = 50

b = 50



... ...



crashed

void * inc_count2(int id)

 ... 




呵呵，好玩。

按照gvim的解释，在111的程序里有3处地方可以改变i，而真正说明问题的只有一种情况。概率为1/3。他也没有办法证明到底某一次切换是发生在这3句中的那一句。

而你的程序，加了两条printf之后，printf翻译成汇编之后是多少句？假设200句汇编吧(不算多吧)，两句就是400条，而概率就变为1/403，甚至少。

那你的程序不是更不能说明什么吗？


 mik 回复于：2006-08-12 20:37:15


引用：原帖由 flw2 于 2006-8-12 10:36 发表

movl $0,%eax

也不是原子的. 






flw2,  我仔细琢磨一下。你所说的还是有一定的道理的。



movl $0, %eax  这句指令应该是原子性的。因为它没有存/取内存的行为。



但：

movl %eax, a  这一条指令，是不能保证它一定是原子性的。



CPU 要将数据存放在内存，必须经过地址总线传递。





考虑以下的一种情况：



在多CPU系统中， CPU 发出指令 要将 eax 数据往 [a] 这个内存里放，经过地址总线，



而正好，另一个CPU 抢先把地址总线占了，那么，第一个CPU 执行的指令应该先被挂起，直至地址总线空闲了，它才可以继续执行写内存的操作。



所以。在多CPU系统里，只有加LOCK了，才能保证其一定是原子性的。



象存/取内存的指令前，应加上:  lock movl %eax, a





然而，在单CPU系统中，一条指令我认为应该是原子性的。


 isjfk 回复于：2006-08-12 21:05:38


多 CPU 的时候也是跟多 CPU 的架构有关系。我记得早期的 486 多处理器，如果一个 CPU 执行的指令需要访问内存，则 CPU 会在这条指令的始终周期内始终占用内存总线。


 mik 回复于：2006-08-12 21:09:48


引用：原帖由 isjfk 于 2006-8-12 21:05 发表

多 CPU 的时候也是跟多 CPU 的架构有关系。我记得早期的 486 多处理器，如果一个 CPU 执行的指令需要访问内存，则 CPU 会在这条指令的始终周期内始终占用内存总线。 






呵呵~~ 若你没记错的话，那就更能说明为什么要在多CPU系统中锁总线了。



写内存指令是要超过一个周期滴


 JohnBull 回复于：2006-08-12 22:53:34


还没争完？？？？

其实就一句话：

CPU不会在一条指令执行期间响应任何中断，其余自己想想就完了。


 JohnBull 回复于：2006-08-12 23:10:13


引用：原帖由 mik 于 2006-8-12 21:09 发表

呵呵~~ 若你没记错的话，那就更能说明为什么要在多CPU系统中锁总线了。

 




锁总线的性能是不能接受的！

现在的基于共享存储的UMA SMP设计，都是使用CACHE来回避总线占用，并采用特定手段解决缓存一致性的问题。



实际上这个帖子的主题根本牵扯不到这个问题。


 ~~~~ 回复于：2006-08-13 07:15:42


mik 想歪了，事实不是你想得那么回事。


 ~~~~ 回复于：2006-08-13 07:16:30


引用：原帖由 JohnBull 于 2006-8-12 23:10 发表



实际上这个帖子的主题根本牵扯不到这个问题。 




挖深点也好啊，让我这样的菜菜多学点:D


 dongpy 回复于：2006-08-13 12:48:24


支持whyglinux的观点～



int赋值操作，不管被分解成多少个汇编指令，只要保证仅有一条指令，完成对目标操作数（即多个线程共享那个变量）的访问，那么这个赋值过程就是原子的，因为那个写操作数的指令是不会被打断的。  



赋值操作中的其余指令只不过是一些辅助操作，比如从局部变量MOV到寄存器，这些操作被中断不会影响整个操作的原子性（因为有现场保护）。


 Alligator27 回复于：2006-08-13 20:53:23


我觉得一个操作是否原子, 要看该操作是否需要多次使用数据总线. 而不是几条指令.



大多数int赋值(立即数)只要一次memory cycle. 是原子的. 另外象 a=b 或 a++, 也许只要一条指令, 但必需读写两个memory cycle, 不是原子的, 需要加锁.



现在的CPU向多核发展, 同步是很重要的. 但code不能依赖某些硬件的实现, 先要保证正确.


 思一克 回复于：2006-08-14 08:57:42


在INTELX86 LINUX 单CPU下（根据LINUX atomic.h代码可以推断在许多其它平台也一样），

应用程序的全局int的读写（无论多thread，还是多PROCESS的shmem)都是原子的。不需要LOCK，放心地使用吧。



此时，C变为一条还是多条汇编无关，原因前面说过了。



多SMP下最好有人帮实验一下。


 思一克 回复于：2006-08-14 09:23:32


这个程序哪位在SMP LINUX机器上帮运行一下。



gcc -lpthread atomic.c -o testa

./testa      没有参数就是用原子复制

./testa X   有任何参数就是故意不用原子复制



如果不是原子的，程序会退出，否则一直跑。还可以观察到count被其它THREAD改了的情况





[CODE]

# include <stdio.h>

# include <stdlib.h>

# include <pthread.h>

# include <unistd.h>



int not_atomic = 0;

int runFlag = 1;

int count = 0;



void *testa( int id );



int main( int argc, char **argv )

{

    pthread_t thread;

    int i, ret;



    if(argc > 1 && argv[0][0]) not_atomic = 1;



    for( i = 0; i < 8; i++ ){

        ret = pthread_create( &thread, NULL, (void *(*)(void *))testa, (void *)i );

        if ( ret != 0 ){

            perror( "pthread_create" );

            exit(-1);

        }

    }

    while(runFlag) sleep(5);

    return 0;

}





void *testa( int id )

{

    int i;

    unsigned int k, v;



    k = 0x11111111*id;

    while(runFlag){

        for( i=0; i<10000; i++ ){

           if(not_atomic == 0) {

                count = k;

           } else {

                ((short*)&count)[0] = ((short*)&k)[0];

                ((short*)&count)[1] = ((short*)&k)[1];

           }

           if(count != k)

                printf("%08x %08x\n", k, count);



           v = count;

           if((v & 0x0000ffff) != (v >> 16)) {

                printf("NOT ATOMIC VALUE FOUND: %p %p\n", v, count);

                runFlag = 0;

           }

        }

    }

    return NULL;

}



[/CODE]


 思一克 回复于：2006-08-14 11:46:38


我找到SMP（2个CPU），运行结果也是和单个CPU一样


 kk_00 回复于：2006-08-15 11:26:16


楼主的问题是不是可以改成:

对于各种CPU来说,中断请求的优先级以及**是否**允许中断的条件判断都是怎么样的. 另外该CPU对延时处理都采用什么方式?


 isjfk 回复于：2006-08-15 11:31:30


晕，还没争完？:em06:


 oyscal 回复于：2006-08-20 22:13:59


如果int a=0;两个线程同时执行一次a++,结果不一定是2，很有可能是1.情况可能会是这样的：

1）线程1将a的值从内存读到寄存器

2）线程1在寄存器里将a＋＋（a＝1）

3）线程2此时被调度，将a的值从内存（注意此时内存里a＝0）读到寄存器

4）线程2在寄存器里a＋＋（a＝1）

5）线程1被调度，将a写回内存，a＝1

6）线程2被调度，也将a写回内存，a＝1



最后a＝1,over！



当然这个跟平台有关，但起码intel 8086体系的cpu是这样处理的


 whyglinux 回复于：2006-08-20 22:59:24


引用：原帖由 oyscal 于 2006-8-20 22:13 发表

如果int a=0;两个线程同时执行一次a++,结果不一定是2，很有可能是1.情况可能会是这样的：

1）线程1将a的值从内存读到寄存器

2）线程1在寄存器里将a＋＋（a＝1）

3）线程2此时被调度，将a的值从内存（注意此时内 ... 




赋值和自加还是有区别的：赋值是一个读－写的过程，而自加是一个读－改－写的过程，比起赋值来多了一个“改”的环节。



而且你上面说的 a++ 出现的问题只会出现在多CPU结构上，对于单CPU来说应该不存在这个问题。


 思一克 回复于：2006-08-21 08:43:49


to oyscal,



global_var++被翻译成为INC GV, 和赋值不是一个语句。赋值是原子的，在SMP多CPU中也是原子的。INC在SMP中不是原子的。你说的是正确的，但忽略了关键

[ 本帖最后由 思一克 于 2006-8-21 08:44 编辑 ]