src/storage/Mutex.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #include <os.h>
  17 #include <Mutex.h>
  18 #include <Debug.h>
  19 #include <NanoTimer.h>
  20 #include <Config.h>
  21 #include <Process.h>
  22 Mutex::Mutex()
  23 {
  24 #if defined(sparc) || defined(i686) || defined(x86_64)
  25     lock =0;
  26 #else
  27     pthread_mutexattr_t attr;
  28     pthread_mutexattr_init(&attr);
  29     pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
  30     pthread_mutex_init(&mutex_, &attr);
  31 #endif
  32 }
  33
  34 int Mutex::init()
  35 {
  36 #if defined(sparc) || defined(i686) || defined(x86_64)
  37     lock = 0;
  38 #else
  39     pthread_mutexattr_t attr;
  40     pthread_mutexattr_init(&attr);
  41     int ret = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
  42     printf("pthread_mutexattr_setpshared Returned %d\n", ret);
  43     pthread_mutex_init(&mutex_, &attr);
  44     pthread_mutexattr_destroy(&attr);
  45 #endif
  46     return 0;
  47 }
  48 int Mutex::init(char *mname)
  49 {
  50     if (strlen(mname) > 19 ) return 0;
  51     init();
  52     strcpy(name, mname);
  53     return 0;
  54
  55 }
  56
  57 #if defined(sparc) || defined(i686) || defined(x86_64)
  58 int TSL(Lock *lock)
  59 {
  60 /*
  61     if (lock == 0) {
  62        __asm("mov  $1, %eax");
  63        __asm("mov 20(%ebp), %edx");
  64        __asm("xchg %eax, (%edx)");
  65        __asm("test %eax %eax");
  66        __asm("jnz .L1000");
  67        return 0;
  68     } else
  69     {
  70         __asm(".L1000:");
  71         return 1;
  72     }
  73 */
  74 /*Was Working in linux
  75         char oldval;
  76         __asm__ __volatile__(
  77                 "xchgb %b0,%1"
  78                 :"=q" (oldval), "=m" (lock)
  79                 :"0" (0) : "memory");
  80
  81         return oldval > 0;
  82 */
  83 #if defined(i686) || defined(x86_64)
  84     int*  lw;
  85     int   res;
  86     lw = (int*)lock;
  87     if (*lock == 1) return 1;
  88     /* In assembly we use the so-called AT & T syntax where
  89     the order of operands is inverted compared to the ordinary Intel
  90     syntax. The 'l' after the mnemonics denotes a 32-bit operation.
  91     The line after the code tells which values come out of the asm
  92     code, and the second line tells the input to the asm code. */
  93
  94     /* This assembly compiles only with -O2 option, and not with -g option. Version1
  95     __asm__ __volatile__(
  96         "movl $1, %%eax; xchgl (%%ecx), %%eax"
  97         : "=eax" (res), "=m" (*lw)
  98         : "ecx" (lw));
  99     */
 100
 101      /* This assembly takes lot of time for test/performance/DMLTest. Version2
 102      __asm__ __volatile__(
 103         "movl %1, %0; xchgl %0, %2"
 104         : "=r" (res), "=r" (lock)
 105         : "r" (lock));
 106      */
 107
 108
 109     // This assembly is Version3. Working fine for now
 110     __asm__ __volatile__(
 111         "xchgl %0, %1 \n\t"
 112         : "=r"(res), "=m"(*lock)
 113         : "0"(1), "m"(*lock)
 114         : "memory");
 115
 116     //fprintf(stderr,"after asm %d ret %d\n", *lock, res);
 117
 118     return(res);
 119
 120 #elif defined (sparc)
 121     Lock res;
 122     __asm__ __volatile__("ldstub  [%2], %0    \n"
 123        "=r"(res), "+m"(*lock)
 124        "r"(lock)
 125        "memory");
 126      return (int) res;
 127 #endif
 128 }
 129 #endif
 130
 131 int Mutex::tryLock(int tryTimes, int waitmsecs)
 132 {
 133     if (TSL(&lock) == 0)
 134     {
 135         return 0;
 136     }
 137     int tries = 1;
 138     int ret = 0;
 139     struct timeval timeout;
 140     timeout.tv_sec = 0;
 141     timeout.tv_usec = waitmsecs;
 142     if (tryTimes == 0 && waitmsecs == 0)
 143     {
 144         timeout.tv_sec = Conf::config.getMutexSecs();
 145         timeout.tv_usec = Conf::config.getMutexUSecs();
 146         tryTimes = Conf::config.getMutexRetries();
 147     }
 148     while (tries < tryTimes)
 149     {
 150 #if defined(sparc) || defined(i686) || defined(x86_64)
 151     if (TSL(&lock) == 0)
 152     {
 153         return 0;
 154     }
 155 #else
 156     ret = pthread_mutex_trylock(&mutex_);
 157     if (EBUSY  != ret) return 0;
 158
 159 #endif
 160         os::select(0, 0, 0, 0, &timeout);
 161         tries++;
 162     }
 163     printError(ErrLockTimeOut, "Unable to get the mutex , tried %d times", tries);
 164     return 1;
 165 }
 166
 167
 168 int Mutex::getLock(int procSlot, bool procAccount)
 169 {
 170     int ret=0;
 171 #if defined(sparc) || defined(i686) || defined(x86_64)
 172     ret = tryLock();
 173     //add it to the has_ of the ThreadInfo
 174     if (ret ==0 && procAccount) ProcessManager::addMutex(this, procSlot);
 175
 176     return ret;
 177 #else
 178     ret = pthread_mutex_lock(&mutex_);
 179 #endif
 180     if (ret == 0) return 0;
 181     else
 182         return 1;
 183 }
 184
 185 int Mutex::releaseLock(int procSlot, bool procAccount)
 186 {
 187     int ret=0;
 188 #if defined(sparc) || defined(i686) || defined(x86_64)
 189     /*int *lw = &lock;
 190     if (*lw == 0) return 0;
 191     __asm__ __volatile__("movl $0, %%eax; xchgl (%%ecx), %%eax" :
 192                       "=m" (*lw) :
 193                       "ecx" (lw) :
 194                       "eax");
 195     */
 196     lock = 0;
 197 #else
 198     ret = pthread_mutex_unlock(&mutex_);
 199 #endif
 200     if (ret == 0 && procAccount)
 201     {
 202         ProcessManager::removeMutex(this, procSlot);
 203         return ret;
 204     }
 205     else
 206         return 1;
 207 }
 208
 209 int Mutex::destroy()
 210 {
 211 #if defined(sparc) || defined(i686) || defined(x86_64)
 212 #else
 213     return pthread_mutex_destroy(&mutex_);
 214 #endif
 215     return 0;
 216 }
 217
 218 int Mutex::recoverMutex()
 219 {
 220     int ret=0;
 221 #if defined(sparc) || defined(i686) || defined(x86_64)
 222     /*int *lw = &lock;
 223     if (*lw == 0) return 0;
 224     __asm__ __volatile__("movl $0, %%eax; xchgl (%%ecx), %%eax" :
 225                       "=m" (*lw) :
 226                       "ecx" (lw) :
 227                       "eax");
 228     */
 229     lock = 0;
 230 #else
 231     ret = pthread_mutex_unlock(&mutex_);
 232 #endif
 233     return ret;
 234 }
 235