include/amino/arch/x86/x86_util.h

Go to the documentation of this file.

/*
 * (c) Copyright 2008, IBM Corporation.
 *
 *      Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef AMINO_UTIL_X86_H
#define AMINO_UTIL_X86_H

const int CACHE_PER_CORE=512000;
const int CACHE_LINE_SIZE=64;

#define LOCK "lock;"

//optimization barrier
#define compiler_barrier()  __asm__ __volatile__ ("":::"memory")

#define LFENCE __asm__ __volatile__ ("lfence":::"memory")
#define SFENCE __asm__ __volatile__ ("sfence":::"memory")
#define CC_FENCE __asm__ __volatile__ ("mfence":::"memory")

#if defined(BIT32)
#define SC_FENCE __asm__ __volatile__ ("mfence":::"memory")
#elif defined(BIT64)
#define SC_FENCE __asm__ __volatile__ (LOCK "addl $0, 0(%%rsp)":::"memory")
#endif


inline int getProcessNum(){
    //TODO add code to get this information
    return 8;
}

inline bool cas(volatile void* address, void* oldV_a, unsigned long newV, int size)
{
    //make sure address alignment
    bool ret;
    switch(size){
        case 1:
            {
                unsigned char* addr = (unsigned char*)address;
                unsigned char* oldV_addr = (unsigned char*)oldV_a;
                __asm__ __volatile__(
                        LOCK "cmpxchgb %b3, %2; setz %0;\n"
                        : "=q"(ret), "=a"(*(oldV_addr)), "=m"(*(addr))
                        : "c" (newV), "1"(*(oldV_addr))
                        : "memory", "cc");
                return ret;
            }
        case 2:
            {
                unsigned short* addr = (unsigned short*)address;
                unsigned short* oldV_addr = (unsigned short*)oldV_a;
                __asm__ __volatile__(
                        LOCK "cmpxchgw %w3, %2; setz %0;\n"
                        : "=q"(ret), "=a"(*(oldV_addr)), "=m"(*(addr))
                        : "r" (newV), "1"(*(oldV_addr))
                        : "memory", "cc");
                return ret;
            }
#if defined(BIT32)
        case 4:
            {
                unsigned long* addr = (unsigned long*)address;
                unsigned long* oldV_addr = (unsigned long*)oldV_a;
                __asm__ __volatile__(
                        LOCK "cmpxchgl %3, %2; setz %0;\n"
                        : "=q"(ret), "=a"(*(oldV_addr)), "=m"(*(addr))
                        : "r" (newV), "1"(*(oldV_addr))
                        : "memory", "cc");
                return ret;
            }
#elif defined(BIT64)
        case 4:
            {
                unsigned int* addr = (unsigned int*)address;
                unsigned int* oldV_addr = (unsigned int*)oldV_a;
                __asm__ __volatile__(
                        LOCK "cmpxchgl %k3, %2; setz %0;\n"
                        : "=q"(ret), "=a"(*(oldV_addr)), "=m"(*(addr))
                        : "r" (newV), "1"(*(oldV_addr))
                        : "memory", "cc");
                return ret;
            }
        case 8:
            {
                unsigned long* addr = (unsigned long*)address;
                unsigned long* oldV_addr = (unsigned long*)oldV_a;
                __asm__ __volatile__(
                        LOCK "cmpxchgq %3, %2; setz %0;\n"
                        : "=q"(ret), "=a"(*(oldV_addr)), "=m"(*(addr))
                        : "r" (newV), "1"(*(oldV_addr))
                        : "memory", "cc");
                return ret;
            }
#endif
    } //end switch
    return false;
}

inline bool casd(volatile void *ptr, void *old_addr, const void * new_v) {
    unsigned long * old_addr_long = (unsigned long *) old_addr;
    const unsigned long * new_v_long = (const unsigned long *) new_v;
    bool ret;
#if defined(BIT64)
    __asm__ __volatile__(
            "lock\n\t"
            "cmpxchg16b %5\n\t"
            "setz %0\n"
            : "=b"(ret), "=d"(old_addr_long[1]), "=a"(old_addr_long[0]) /*Output*/
            : "0"(new_v_long[0]), /*Input*/
            "c"(new_v_long[1]),
            "m"(*(long *)ptr),
            "1"(old_addr_long[1]),
            "2"(old_addr_long[0])
            : "memory", "cc"); /*Overwrites*/
#else
#ifdef __PIC__

    __asm__ __volatile__(
            "push   %%ebx     \n\t"
            "movl  %3,  %%ebx   \n\t"
            "lock   \n\t"
            "cmpxchg8b  %5       \n\t"
            "setz   %0 \n\t"
            "popl   %%ebx   \n\t"
            : "=q"(ret), "=d"(old_addr_long[1]), "=a"(old_addr_long[0]) /*Output*/
            : "m"(new_v_long[0]), /*Input*/
            "c"(new_v_long[1]),
            "m"(*((long*)(ptr))),
            "1"(old_addr_long[1]),
            "2"(old_addr_long[0])
            : "memory", "cc");
#else
    __asm__ __volatile__(
            "lock   \n\t"
            "cmpxchg8b  %5       \n\t"
            "setz   %0 \n\t"
            : "=b"(ret), "=d"(old_addr_long[1]), "=a"(old_addr_long[0]) /*Output*/
            : "0"(new_v_long[0]), /*Input*/
            "c"(new_v_long[1]),
            "m"(*((long*)(ptr))),
            "1"(old_addr_long[1]),
            "2"(old_addr_long[0])
            : "memory", "cc");
#endif //__PIC__
#endif //BIT64
    return ret;
}

inline unsigned long xchg(volatile void * ptr, unsigned long v, int size)
{
    switch (size) {
        case 1:
            {
                unsigned char* addr = (unsigned char*)ptr;
                __asm__ __volatile__("xchgb %b0,%1"
                        :"=q" (v)                /* cannot be r ? */
                        :"m" (*addr), "0" (v)
                        :"memory");
                break;
            }
        case 2:
            {
                unsigned short* addr = (unsigned short*)ptr;
                __asm__ __volatile__("xchgw %w0,%1"
                        :"=r" (v)
                        :"m" (*addr), "0" (v)
                        :"memory");
                break;
            }
#if defined(__i386__)
        case 4:
            {
                unsigned long* addr = (unsigned long*)ptr;
                __asm__ __volatile__("xchgl %0,%1"
                        :"=r" (v)
                        :"m" (*addr), "0" (v)
                        :"memory");
                break;
            }
#elif defined(__x86_64__)
        case 4:
            {
                unsigned int* addr = (unsigned int*)ptr;
                __asm__ __volatile__("xchgl %k0,%1"
                        :"=r" (v)
                        :"m" (*addr), "0" (v)
                        :"memory");
                break;
            }
        case 8:
            {
                unsigned long* addr = (unsigned long*)ptr;
                __asm__ __volatile__("xchgq %0,%1"
                        :"=r" (v)
                        :"m" (*addr), "0" (v)
                        :"memory");
                break;
            }
#endif
    }
    return v; //the value stored in *ptr before this xchg
}
#endif

---