memcache bench

memcache_bench_2010.py

#!/usr/bin/env python

import threading
import memcache
import Queue
import inspect
import uuid
import time


Servers = ["127.0.0.1:11211"]

Byte10 = "0123456789"
Byte1k = Byte10 * 100
Byte1M = Byte1k * 1000

class Bench(threading.Thread):
  Lock = threading.Lock()
  
  def __init__(self, prefix=None, count=10):
      super(Bench, self).__init__()
      
      if prefix is None:
        prefix = str(uuid.uuid4())

      
      self.prefix = prefix
      self.mc = memcache.Client(Servers)
      self.count = count
      self.request = Queue.Queue()
      self.event = threading.Event()
    
  def req_end(self):
    self.request.put(True)

  def req_set(self):
    self.request.put(self._set)

  def req_get(self):
    self.request.put(self._get)

  def _print(self):
    for a in xrange(self.count):
      Bench.Lock.acquire()
      print "set:%s:%d" % (self.prefix, a)
      Bench.Lock.release()
    
  def _set1(self):
    for a in xrange(self.count):
      self.mc.set(self.prefix, self.prefix)

  def _get1(self):
    for a in xrange(self.count):
      self.mc.get(self.prefix)

  def _set(self):
    for a in xrange(self.count):
      key = self.prefix + str(a)
      self.mc.set(key, self.prefix)

  def _get(self):
    for a in xrange(self.count):
      key = self.prefix + str(a)
      self.mc.get(key)

  def _del1(self):
    self.mc.delete(self.prefix)

  def _delete(self):
    for a in xrange(self.count):
      key = self.prefix + str(a)
      self.mc.delete(key)
      
    
  def wait(self):
    self.event.wait()
  
  def run(self):
    while True:
      self.event.set()
      task = self.request.get()

      try:
        if inspect.ismethod(task):
          task()
          
        else:
          print "catch end"
          break
      
      finally:
        self.event.clear()

      
class Pool(object):
  def __init__(self, thread_count, each_count):
    super(Pool, self).__init__()
    
    self._threads = []
    
    for b in xrange(thread_count):
      t = Bench(str(b), each_count)
      t.start()
      self._threads.append(t)

  def _wait(self):
    for t in self._threads:
      t.wait()


  def set(self):
    for t in self._threads:
      t.req_set()

    self._wait()
    
  def get(self):
    for t in self._threads:
      t.req_get()

    self._wait()
      
  def end(self):
    for t in self._threads:
      t.req_end()

    self._wait()
    


if __name__ == "__main__":
  p = Pool(10, 10)
  
  t = time.time()
  p.set()
  t2 = time.time()
  print t2 - t
  t = t2
  
  p.end()