To Home page

Write your own InterlockedXxx operation

It has long been known that InterlockedCompareExchange can be used to write any Interlockedxxx operation. 

long InterlockedXxx(
        __inout long  volatile *Target,
        , whatever parameters we need for Xxx
        long prevValue, prevCopy;

        prevValue = *Target;

        do {
            if Xxx operations is illegal on prevValue, return with error code

            prevCopy = prevValue;

            // prevValue will be the value that used to be Target if the exchange was made
            // or its current value if the exchange was not made.
            prevValue = InterlockedCompareExchange(Target, Xxx operation on prevCopy, prevValue);

            // If prevCopy == prevValue, then no one updated Target in between the deref at the top
            // and the InterlockecCompareExchange afterward and we are done
        } while (prevCopy != prevValue);

        // [value] can be anything you want, but it is typically either
        // a) The new value stored in Target.  This is the type of return value that
        //    InterlockedIncrement returns
        // or
        // b) The new value is the previous value that was in Target.  This si the
        //     type of return value that InterlockedOr or InterlockedExchange return
        return [value];

Structures larger than a long can be handled by using InterlockedCompareExchange to add to a linked list, or remove stuff from a linked list. Of course you should not be writing such things yourself, when Intel has already written it for you. 

These documents are licensed under the Creative Commons Attribution-Share Alike 3.0 License