Read-Write Lock vs primitive Lock()

[k3xji]

Hi,

I  am trying to see on which situations does the Read-Write Lock
performs better on primitive Lock() itself. Below is the code I am
using to test the performance:
import threading
import locks
import time

class mylock(object):
    def __init__(self):
        self.__notreading = threading.Event()
        self.__notwriting = threading.Event()
        self.__notreading.set()
        self.__notwriting.set()
    def acquire_read(self):
        self.__notreading.clear()
        self.__notwriting.wait()
    def acquire_write(self):
        self.__notreading.wait()
        self.__notwriting.clear()
    def release_read(self):
        self.__notreading.set()
    def release_write(self):
        self.__notwriting.set()

GLOBAL_VAR = 1
#GLOBAL_LOCK = locks.ReadWriteLock()
GLOBAL_LOCK = threading.Lock()
#GLOBAL_LOCK = mylock()
GLOBAL_LOOP_COUNT = 100000
GLOBAL_READER_COUNT = 1000
GLOBAL_WRITER_COUNT = 1



class wthread(threading.Thread):
    def run(self):
            try:
                #GLOBAL_LOCK.acquireWrite()
                #GLOBAL_LOCK.acquire_write()
                GLOBAL_LOCK.acquire()
                for i in range(GLOBAL_LOOP_COUNT):
                    GLOBAL_VAR = 4
            finally:
                #GLOBAL_LOCK.release_write()
                GLOBAL_LOCK.release()

class rthread(threading.Thread):
    def run(self):
            try:
                #GLOBAL_LOCK.acquireRead()
                #GLOBAL_LOCK.acquire_read()
                GLOBAL_LOCK.acquire()
                for i in range(GLOBAL_LOOP_COUNT):
                    GLOBAL_VAR = 3
            finally:
                #GLOBAL_LOCK.release_read()
                GLOBAL_LOCK.release()

# module executed?
if __name__ == "__main__":
    starttime = time.clock()
    threads = []
    for i in range(GLOBAL_READER_COUNT):
        rt = rthread()
        threads.append(rt)
    for i in range(GLOBAL_WRITER_COUNT):
        wt = wthread()
        threads.append(wt)

    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
    print "All operations took " + str(time.clock() - starttime) + "
msecs"


What I am doing is: I am creating multiple readers and try to do
something. I had assumed that with using primitive Lock() on the above
situation, it will create a bottleneck on the rthreads. But the
numbers indicate that there are no difference at all. I had
implemented my own READ-WRIET lock as can be seen above mylock and
also used the one here: code.activestate.com/recipes/502283/.

Both have the same numbers:
above test with primitive Lock:
C:\Python25\mytest>python test_rw.py
All operations took 14.4584082614 msecs
above test with mylock:
C:\Python25\mytest>python test_rw.py
All operations took 14.5185156214 msecs
abive test with the one in recipe:
C:\Python25\mytest>python test_rw.py
All operations took 14.4641975447 msecs

So, I am confused in which situations Read-Write lock scales better?

Thanks,