Note: This website is archived. For up-to-date information about D projects and development, please visit wiki.dlang.org.

Changeset 479

Show
Ignore:
Timestamp:
01/06/11 07:32:54 (14 years ago)
Author:
braddr
Message:

Fix atomicLoad for 64 bit. Add a little unit testing for atomic operations.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/core/atomic.d

    r452 r479  
    601600                        mov AL, 0; 
    602601                        mov RCX, val; 
    603602                        lock; // lock always needed to make this op atomic 
    604603                        cmpxchg [RCX], DL; 
    605604                    } 
    606605                } 
    607606                else 
    608607                { 
    609608                    asm 
    610609                    { 
    611                         mov AL, [val]; 
     610                        mov RAX, val; 
     611                        mov AL, [RAX]; 
    612612                    } 
    613613                } 
    614614            } 
    615615            else static if( T.sizeof == short.sizeof ) 
    616616            { 
    617617                ////////////////////////////////////////////////////////////////// 
    618618                // 2 Byte Load 
    619619                ////////////////////////////////////////////////////////////////// 
    620620 
    621621 
    …… 
    627627                        mov AX, 0; 
    628628                        mov RCX, val; 
    629629                        lock; // lock always needed to make this op atomic 
    630630                        cmpxchg [RCX], DX; 
    631631                    } 
    632632                } 
    633633                else 
    634634                { 
    635635                    asm 
    636636                    { 
    637                         mov AX, [val]; 
     637                        mov RAX, val; 
     638                        mov AX, [RAX]; 
    638639                    } 
    639640                } 
    640641            } 
    641642            else static if( T.sizeof == int.sizeof ) 
    642643            { 
    643644                ////////////////////////////////////////////////////////////////// 
    644645                // 4 Byte Load 
    645646                ////////////////////////////////////////////////////////////////// 
    646647 
    647648 
    …… 
    653654                        mov EAX, 0; 
    654655                        mov RCX, val; 
    655656                        lock; // lock always needed to make this op atomic 
    656657                        cmpxchg [RCX], EDX; 
    657658                    } 
    658659                } 
    659660                else 
    660661                { 
    661662                    asm 
    662663                    { 
    663                         mov EAX, [val]; 
     664                        mov RAX, val; 
     665                        mov EAX, [RAX]; 
    664666                    } 
    665667                } 
    666668            } 
    667669            else static if( T.sizeof == long.sizeof ) 
    668670            { 
    669671                ////////////////////////////////////////////////////////////////// 
    670672                // 8 Byte Load 
    671673                ////////////////////////////////////////////////////////////////// 
    672674 
    673675 
    …… 
    679681                        mov RAX, 0; 
    680682                        mov RCX, val; 
    681683                        lock; // lock always needed to make this op atomic 
    682684                        cmpxchg [RCX], RDX; 
    683685                    } 
    684686                } 
    685687                else 
    686688                { 
    687689                    asm 
    688690                    { 
    689                         mov RAX, [val]; 
     691                        mov RAX, val; 
     692                        mov RAX, [RAX]; 
    690693                    } 
    691694                } 
    692695            } 
    693696            else 
    694697            { 
    695698                static assert( false, "Invalid template type specified." ); 
    696699            } 
    697700        } 
    698701    } 
    699702} 
    …… 
    742745        testType!(int)(); 
    743746        testType!(uint)(); 
    744747 
    745748        testType!(int*)(); 
    746749 
    747750        static if( has64BitCAS ) 
    748751        { 
    749752            testType!(long)(); 
    750753            testType!(ulong)(); 
    751754        } 
     755 
     756        size_t i; 
     757 
     758        atomicOp!"+="(i, cast(size_t)1); 
     759        assert(i == 1); 
     760 
     761        atomicOp!"-="(i, cast(size_t)1); 
     762        assert(i == 0); 
    752763    } 
    753764}