Author: Remi Meier <[email protected]>
Branch: multithread-runner
Changeset: r355:47e822fcaecf
Date: 2016-05-27 15:55 +0200
http://bitbucket.org/pypy/benchmarks/changeset/47e822fcaecf/
Log: add some configs, fix some benchmarks
diff --git a/multithread/btree/btree.py b/multithread/btree/btree.py
--- a/multithread/btree/btree.py
+++ b/multithread/btree/btree.py
@@ -2,7 +2,7 @@
from common.abstract_threading import (
atomic, Future, set_thread_pool, ThreadPool,
- hint_commit_soon, print_abort_info)
+ hint_commit_soon, turn_jitting_off)
import time, threading
import random
@@ -205,7 +205,7 @@
ancestors.append((node, index))
node, index = ancestors.pop()
node.insert(index, item, ancestors)
- hint_commit_soon()
+ #hint_commit_soon()
return True
def remove(self, item):
@@ -214,7 +214,7 @@
if self._present(item, ancestors):
node, index = ancestors.pop()
node.remove(index, ancestors)
- hint_commit_soon()
+ #hint_commit_soon()
# else:
# raise ValueError("%r not in %s" % (item,
self.__class__.__name__))
@@ -312,7 +312,7 @@
######################################################################
CONFLICTING = [BTree.insert, BTree.remove]
-OPS = [BTree.__contains__] * 98 + CONFLICTING
+OPS = [BTree.__contains__] * 198 + CONFLICTING
ITEM_RANGE = 10000
@@ -341,20 +341,23 @@
-def run(threads=2, operations=2000000):
+def run(threads=2, concurrency=8, operations=2000000):
threads = int(threads)
operations = int(operations)
- set_thread_pool(ThreadPool(threads))
+ tp = ThreadPool(threads)
+ print "new tp"
+ set_thread_pool(tp)
+ print "tp active"
tree = BTree(20)
for _ in xrange(1000):
tree.insert(random.randint(1, ITEM_RANGE))
- c_len = operations // threads
+ c_len = operations // concurrency
fs = []
parallel_time = time.time()
- for i in xrange(threads):
+ for i in xrange(concurrency):
fs.append(Future(task, i, tree, c_len))
for f in fs:
f()
@@ -369,6 +372,28 @@
+def main(argv):
+ # warmiters threads args...
+ warmiters = int(argv[0])
+ threads = int(argv[1])
+ cs, ops = int(argv[2]), int(argv[3])
+
+ print "params (iters, threads, concs, ops):", warmiters, threads, cs, ops
+
+ print "do warmup:"
+ for i in range(3):
+ print "iter", i, "time:", run(threads, cs, ops)
+
+ print "turn off jitting"
+ import gc
+ turn_jitting_off()
+ print "do", warmiters, "real iters:"
+ times = []
+ for i in range(warmiters):
+ gc.collect()
+ times.append(run(threads, cs, ops))
+ print "warmiters:", times
if __name__ == '__main__':
- run()
+ import sys
+ main(sys.argv[1:])
diff --git a/multithread/config-btree.json b/multithread/config-btree.json
new file mode 100644
--- /dev/null
+++ b/multithread/config-btree.json
@@ -0,0 +1,21 @@
+{
+ "defaults": {
+ "file": null,
+ "threads": [1, 2, 4, 8],
+ "vmstarts": 3,
+ "warmiters": 3,
+ "PYTHONPATH": ".",
+ "args": [],
+ "cwd": "."
+ },
+
+ "benchs": {
+ "btree": {
+ "file": "btree/btree.py",
+ "PYTHONPATH": "..",
+ "vmstarts": 3,
+ "warmiters": 3,
+ "args": ["16", "500000"]
+ }
+ }
+}
diff --git a/multithread/config-mandelbrot.json
b/multithread/config-mandelbrot.json
new file mode 100644
--- /dev/null
+++ b/multithread/config-mandelbrot.json
@@ -0,0 +1,21 @@
+{
+ "defaults": {
+ "file": null,
+ "threads": [1, 2, 4, 8],
+ "vmstarts": 3,
+ "warmiters": 5,
+ "PYTHONPATH": ".",
+ "args": [],
+ "cwd": "."
+ },
+
+ "benchs": {
+ "mandelbrot": {
+ "file": "mandelbrot/mandelbrot.py",
+ "PYTHONPATH": "..",
+ "vmstarts": 3,
+ "warmiters": 3,
+ "args": ["64", "512", "512"]
+ }
+ }
+}
diff --git a/multithread/config-nqueens.json b/multithread/config-nqueens.json
new file mode 100644
--- /dev/null
+++ b/multithread/config-nqueens.json
@@ -0,0 +1,21 @@
+{
+ "defaults": {
+ "file": null,
+ "threads": [1, 2, 4, 8],
+ "vmstarts": 3,
+ "warmiters": 5,
+ "PYTHONPATH": ".",
+ "args": [],
+ "cwd": "."
+ },
+
+ "benchs": {
+ "nqueens": {
+ "file": "nqueens/nqueens.py",
+ "PYTHONPATH": "..",
+ "vmstarts": 3,
+ "warmiters": 3,
+ "args": ["10"]
+ }
+ }
+}
diff --git a/multithread/config-richards.json b/multithread/config-richards.json
new file mode 100644
--- /dev/null
+++ b/multithread/config-richards.json
@@ -0,0 +1,21 @@
+{
+ "defaults": {
+ "file": null,
+ "threads": [1, 2, 4, 8],
+ "vmstarts": 3,
+ "warmiters": 5,
+ "PYTHONPATH": ".",
+ "args": [],
+ "cwd": "."
+ },
+
+ "benchs": {
+ "richards": {
+ "file": "richards/richards.py",
+ "PYTHONPATH": "..",
+ "vmstarts": 3,
+ "warmiters": 3,
+ "args": ["30"]
+ }
+ }
+}
diff --git a/multithread/config-skiplist.json b/multithread/config-skiplist.json
new file mode 100644
--- /dev/null
+++ b/multithread/config-skiplist.json
@@ -0,0 +1,21 @@
+{
+ "defaults": {
+ "file": null,
+ "threads": [1, 2, 4, 8],
+ "vmstarts": 3,
+ "warmiters": 3,
+ "PYTHONPATH": ".",
+ "args": [],
+ "cwd": "."
+ },
+
+ "benchs": {
+ "skiplist": {
+ "file": "skiplist/skiplist.py",
+ "PYTHONPATH": "..",
+ "vmstarts": 3,
+ "warmiters": 3,
+ "args": ["16", "200000"]
+ }
+ }
+}
diff --git a/multithread/mandelbrot/mandelbrot.py
b/multithread/mandelbrot/mandelbrot.py
--- a/multithread/mandelbrot/mandelbrot.py
+++ b/multithread/mandelbrot/mandelbrot.py
@@ -1,15 +1,17 @@
-from common.abstract_threading import atomic, Future, set_thread_pool,
ThreadPool
+from common.abstract_threading import (
+ atomic, Future, set_thread_pool, ThreadPool,
+ turn_jitting_off)
import sys, time
def calculate(a, b, im_size, max_iter=255):
- print "a:%s, b:%s, im_size:%s" % (a, b, im_size)
+ #print "a:%s, b:%s, im_size:%s" % (a, b, im_size)
ar, ai = a
br, bi = b
width, height = im_size
imag_step = (bi - ai) / (height - 1)
real_step = (br - ar) / (width - 1)
- print "real/width:%s, imag/height:%s" % (real_step, imag_step)
+ #print "real/width:%s, imag/height:%s" % (real_step, imag_step)
result = [[0] * width for y in xrange(height)]
for y in xrange(height):
@@ -82,8 +84,32 @@
return parallel_time
+def main(argv):
+ # warmiters threads args...
+ warmiters = int(argv[0])
+ threads = int(argv[1])
+ stripes, w, h = int(argv[2]), int(argv[3]), int(argv[4])
+
+ print "params (iters, threads, s, w, h):", warmiters, threads, stripes, w,
h
+
+ print "do warmup:"
+ for i in range(3):
+ print "iter", i, "time:", run(threads, stripes, w, h)
+
+ print "turn off jitting"
+ import gc
+ turn_jitting_off()
+ print "do", warmiters, "real iters:"
+ times = []
+ for i in range(warmiters):
+ gc.collect()
+ times.append(run(threads, stripes, w, h))
+ print "warmiters:", times
if __name__ == '__main__':
- image = run(int(sys.argv[1]), int(sys.argv[2]))
- #save_to_file(out_image)
- save_img(out_image)
+ main(sys.argv[1:])
+
+# if __name__ == '__main__':
+# image = run(int(sys.argv[1]), int(sys.argv[2]))
+# #save_to_file(out_image)
+# save_img(out_image)
diff --git a/multithread/nqueens/nqueens.py b/multithread/nqueens/nqueens.py
--- a/multithread/nqueens/nqueens.py
+++ b/multithread/nqueens/nqueens.py
@@ -8,10 +8,10 @@
import sys
-import time, random
+import time
from common.abstract_threading import (
atomic, Future, set_thread_pool, ThreadPool,
- hint_commit_soon)
+ hint_commit_soon, turn_jitting_off)
from itertools import permutations
import itertools
@@ -28,7 +28,7 @@
def check_solutions(n, cols, perms):
sols = []
- with atomic:
+ if 1: #with atomic:
for vec in perms:
if n == len(set(vec[i]+i for i in cols)) \
== len(set(vec[i]-i for i in cols)):
@@ -41,7 +41,6 @@
fs = []
cols = range(n)
for perms in chunks(permutations(cols), 100000):
- hint_commit_soon()
fs.append(Future(check_solutions, n, cols, perms))
print "Futures:", len(fs)
for f in fs:
@@ -58,11 +57,36 @@
find_solutions(n)
-
# shutdown current pool
set_thread_pool(None)
+def main(argv):
+ # warmiters threads args...
+ warmiters = int(argv[0])
+ threads = int(argv[1])
+ n = int(argv[2])
+
+ print "params (iters, threads, n):", warmiters, threads, n
+
+ print "do warmup:"
+ for i in range(3):
+ t = time.time()
+ run(threads, n)
+ print "iter", i, "time:", time.time() - t
+
+ print "turn off jitting"
+ import gc
+ turn_jitting_off()
+ print "do", warmiters, "real iters:"
+ times = []
+ for i in range(warmiters):
+ gc.collect()
+ t = time.time()
+ run(threads, n)
+ times.append(time.time() - t)
+ print "warmiters:", times
if __name__ == "__main__":
- run()
+ import sys
+ main(sys.argv[1:])
diff --git a/multithread/richards/richards.py b/multithread/richards/richards.py
new file mode 100755
--- /dev/null
+++ b/multithread/richards/richards.py
@@ -0,0 +1,471 @@
+# based on a Java version:
+# Based on original version written in BCPL by Dr Martin Richards
+# in 1981 at Cambridge University Computer Laboratory, England
+# and a C++ version derived from a Smalltalk version written by
+# L Peter Deutsch.
+# Java version: Copyright (C) 1995 Sun Microsystems, Inc.
+# Translation from C++, Mario Wolczko
+# Outer loop added by Alex Jacoby
+
+import thread, os
+from common.abstract_threading import atomic, hint_commit_soon
+
+# Task IDs
+I_IDLE = 1
+I_WORK = 2
+I_HANDLERA = 3
+I_HANDLERB = 4
+I_DEVA = 5
+I_DEVB = 6
+
+# Packet types
+K_DEV = 1000
+K_WORK = 1001
+
+# Packet
+
+BUFSIZE = 4
+
+BUFSIZE_RANGE = range(BUFSIZE)
+
+class Packet(object):
+ def __init__(self,l,i,k):
+ self.link = l
+ self.ident = i
+ self.kind = k
+ self.datum = 0
+ self.data = [0] * BUFSIZE
+
+ def append_to(self,lst):
+ self.link = None
+ if lst is None:
+ return self
+ else:
+ p = lst
+ next = p.link
+ while next is not None:
+ p = next
+ next = p.link
+ p.link = self
+ return lst
+
+# Task Records
+
+class TaskRec(object):
+ pass
+
+class DeviceTaskRec(TaskRec):
+ def __init__(self):
+ self.pending = None
+
+class IdleTaskRec(TaskRec):
+ def __init__(self):
+ self.control = 1
+ self.count = 10000
+
+class HandlerTaskRec(TaskRec):
+ def __init__(self):
+ self.work_in = None
+ self.device_in = None
+
+ def workInAdd(self,p):
+ self.work_in = p.append_to(self.work_in)
+ return self.work_in
+
+ def deviceInAdd(self,p):
+ self.device_in = p.append_to(self.device_in)
+ return self.device_in
+
+class WorkerTaskRec(TaskRec):
+ def __init__(self):
+ self.destination = I_HANDLERA
+ self.count = 0
+# Task
+
+class TaskState(object):
+ def __init__(self):
+ self.packet_pending = True
+ self.task_waiting = False
+ self.task_holding = False
+
+ def packetPending(self):
+ self.packet_pending = True
+ self.task_waiting = False
+ self.task_holding = False
+ return self
+
+ def waiting(self):
+ self.packet_pending = False
+ self.task_waiting = True
+ self.task_holding = False
+ return self
+
+ def running(self):
+ self.packet_pending = False
+ self.task_waiting = False
+ self.task_holding = False
+ return self
+
+ def waitingWithPacket(self):
+ self.packet_pending = True
+ self.task_waiting = True
+ self.task_holding = False
+ return self
+
+ def isPacketPending(self):
+ return self.packet_pending
+
+ def isTaskWaiting(self):
+ return self.task_waiting
+
+ def isTaskHolding(self):
+ return self.task_holding
+
+ def isTaskHoldingOrWaiting(self):
+ return self.task_holding or (not self.packet_pending and
self.task_waiting)
+
+ def isWaitingWithPacket(self):
+ return self.packet_pending and self.task_waiting and not
self.task_holding
+
+
+
+
+
+tracing = False
+layout = 0
+
+def trace(a):
+ global layout
+ layout -= 1
+ if layout <= 0:
+ print
+ layout = 50
+ print a,
+
+
+TASKTABSIZE = 10
+
+class TaskWorkArea(object):
+ def __init__(self):
+ self.taskTab = [None] * TASKTABSIZE
+
+ self.taskList = None
+
+ self.holdCount = 0
+ self.qpktCount = 0
+
+class Task(TaskState):
+
+
+ def __init__(self,i,p,w,initialState,r, taskWorkArea):
+ self.taskWorkArea = taskWorkArea
+ self.link = taskWorkArea.taskList
+ self.ident = i
+ self.priority = p
+ self.input = w
+
+ self.packet_pending = initialState.isPacketPending()
+ self.task_waiting = initialState.isTaskWaiting()
+ self.task_holding = initialState.isTaskHolding()
+
+ self.handle = r
+
+ taskWorkArea.taskList = self
+ taskWorkArea.taskTab[i] = self
+
+ def fn(self,pkt,r):
+ raise NotImplementedError
+
+
+ def addPacket(self,p,old):
+ if self.input is None:
+ self.input = p
+ self.packet_pending = True
+ if self.priority > old.priority:
+ return self
+ else:
+ p.append_to(self.input)
+ return old
+
+
+ def runTask(self):
+ if self.isWaitingWithPacket():
+ msg = self.input
+ self.input = msg.link
+ if self.input is None:
+ self.running()
+ else:
+ self.packetPending()
+ else:
+ msg = None
+
+ return self.fn(msg,self.handle)
+
+
+ def waitTask(self):
+ self.task_waiting = True
+ return self
+
+
+ def hold(self):
+ self.taskWorkArea.holdCount += 1
+ self.task_holding = True
+ return self.link
+
+
+ def release(self,i):
+ t = self.findtcb(i)
+ t.task_holding = False
+ if t.priority > self.priority:
+ return t
+ else:
+ return self
+
+
+ def qpkt(self,pkt):
+ t = self.findtcb(pkt.ident)
+ self.taskWorkArea.qpktCount += 1
+ pkt.link = None
+ pkt.ident = self.ident
+ return t.addPacket(pkt,self)
+
+
+ def findtcb(self,id):
+ t = self.taskWorkArea.taskTab[id]
+ if t is None:
+ raise Exception("Bad task id %d" % id)
+ return t
+
+
+# DeviceTask
+
+
+class DeviceTask(Task):
+ def __init__(self,i,p,w,s,r, taskWorkArea):
+ Task.__init__(self,i,p,w,s,r, taskWorkArea)
+
+ def fn(self,pkt,r):
+ d = r
+ assert isinstance(d, DeviceTaskRec)
+ if pkt is None:
+ pkt = d.pending
+ if pkt is None:
+ return self.waitTask()
+ else:
+ d.pending = None
+ return self.qpkt(pkt)
+ else:
+ d.pending = pkt
+ if tracing: trace(pkt.datum)
+ return self.hold()
+
+
+
+class HandlerTask(Task):
+ def __init__(self,i,p,w,s,r, taskWorkArea):
+ Task.__init__(self,i,p,w,s,r, taskWorkArea)
+
+ def fn(self,pkt,r):
+ h = r
+ assert isinstance(h, HandlerTaskRec)
+ if pkt is not None:
+ if pkt.kind == K_WORK:
+ h.workInAdd(pkt)
+ else:
+ h.deviceInAdd(pkt)
+ work = h.work_in
+ if work is None:
+ return self.waitTask()
+ count = work.datum
+ if count >= BUFSIZE:
+ h.work_in = work.link
+ return self.qpkt(work)
+
+ dev = h.device_in
+ if dev is None:
+ return self.waitTask()
+
+ h.device_in = dev.link
+ dev.datum = work.data[count]
+ work.datum = count + 1
+ return self.qpkt(dev)
+
+# IdleTask
+
+
+class IdleTask(Task):
+ def __init__(self,i,p,w,s,r, taskWorkArea):
+ Task.__init__(self,i,0,None,s,r, taskWorkArea)
+
+ def fn(self,pkt,r):
+ i = r
+ assert isinstance(i, IdleTaskRec)
+ i.count -= 1
+ if i.count == 0:
+ return self.hold()
+ elif i.control & 1 == 0:
+ i.control /= 2
+ return self.release(I_DEVA)
+ else:
+ i.control = i.control/2 ^ 0xd008
+ return self.release(I_DEVB)
+
+
+# WorkTask
+
+
+A = ord('A')
+
+class WorkTask(Task):
+ def __init__(self,i,p,w,s,r, taskWorkArea):
+ Task.__init__(self,i,p,w,s,r, taskWorkArea)
+
+ def fn(self,pkt,r):
+ w = r
+ assert isinstance(w, WorkerTaskRec)
+ if pkt is None:
+ return self.waitTask()
+
+ if w.destination == I_HANDLERA:
+ dest = I_HANDLERB
+ else:
+ dest = I_HANDLERA
+
+ w.destination = dest
+ pkt.ident = dest
+ pkt.datum = 0
+
+ for i in BUFSIZE_RANGE: # xrange(BUFSIZE)
+ w.count += 1
+ if w.count > 26:
+ w.count = 1
+ pkt.data[i] = A + w.count - 1
+
+ return self.qpkt(pkt)
+
+try:
+ from time import time
+except ImportError:
+ def time():
+ return 0
+
+
+def schedule(taskWorkArea):
+ t = taskWorkArea.taskList
+ while t is not None:
+ pkt = None
+
+ if tracing:
+ print "tcb =",t.ident
+
+ if t.isTaskHoldingOrWaiting():
+ t = t.link
+ else:
+ if tracing: trace(chr(ord("0")+t.ident))
+ t = t.runTask()
+
+class Richards(object):
+
+ def __init__(self):
+ self.finished_lock = thread.allocate_lock()
+ self.finished_lock.acquire()
+
+ def run_and_unlock(self, count):
+ print 'running...'
+ iterations = 0
+ self.result = True
+ for i in range(count):
+ self.result = self.run()
+ print 'done, iterations=%d, result=%r' % (count, self.result)
+ self.finished_lock.release()
+
+ def run(self):
+ #hint_commit_soon()
+ #with atomic:
+ if 1:
+ taskWorkArea = TaskWorkArea()
+
+ IdleTask(I_IDLE, 1, 10000, TaskState().running(), IdleTaskRec(),
+ taskWorkArea)
+
+ wkq = Packet(None, 0, K_WORK)
+ wkq = Packet(wkq , 0, K_WORK)
+ WorkTask(I_WORK, 1000, wkq, TaskState().waitingWithPacket(),
WorkerTaskRec(),
+ taskWorkArea)
+
+ wkq = Packet(None, I_DEVA, K_DEV)
+ wkq = Packet(wkq , I_DEVA, K_DEV)
+ wkq = Packet(wkq , I_DEVA, K_DEV)
+ HandlerTask(I_HANDLERA, 2000, wkq,
TaskState().waitingWithPacket(), HandlerTaskRec(),
+ taskWorkArea)
+
+ wkq = Packet(None, I_DEVB, K_DEV)
+ wkq = Packet(wkq , I_DEVB, K_DEV)
+ wkq = Packet(wkq , I_DEVB, K_DEV)
+ HandlerTask(I_HANDLERB, 3000, wkq,
TaskState().waitingWithPacket(), HandlerTaskRec(),
+ taskWorkArea)
+
+ wkq = None;
+ DeviceTask(I_DEVA, 4000, wkq, TaskState().waiting(),
DeviceTaskRec(),
+ taskWorkArea)
+ DeviceTask(I_DEVB, 5000, wkq, TaskState().waiting(),
DeviceTaskRec(),
+ taskWorkArea)
+
+ schedule(taskWorkArea)
+
+ if taskWorkArea.holdCount == 9297 and taskWorkArea.qpktCount ==
23246:
+ pass
+ else:
+ return False
+ #hint_commit_soon()
+
+ return True
+
+def entry_point(iterations, NUM_THREADS):
+ rlist = [Richards() for i in range(NUM_THREADS)]
+ startTime = time()
+ for i, r in enumerate(rlist):
+ count = (iterations * (i + 1)) // NUM_THREADS
+ count -= (iterations * i) // NUM_THREADS
+ thread.start_new_thread(r.run_and_unlock, (count,))
+ for r in rlist:
+ r.finished_lock.acquire()
+ endTime = time()
+ result = all(r.result for r in rlist)
+ return result, startTime, endTime
+
+def main(argv):
+ #def main(entry_point = entry_point, iterations = 10, threads = 4):
+ warmiters = int(argv[0])
+ threads = int(argv[1])
+ iterations = int(argv[2])
+
+ print "params:", warmiters, threads, iterations
+ print "do warmup:"
+ result, startTime, endTime = entry_point(4, threads)
+
+ print "do", warmiters, "real iters:"
+ times = []
+ import gc
+ for i in range(warmiters):
+ gc.collect()
+
+ print "Richards benchmark (Python) starting..."
+ result, startTime, endTime = entry_point(iterations, threads)
+ if not result:
+ print "Incorrect results!"
+ return -1
+ print "finished."
+ total_s = endTime - startTime
+ print "Total time for %d iterations: %.2f secs" %(iterations,total_s)
+ print "Average time per iteration: %.2f ms" %(total_s*1000/iterations)
+
+ times.append(total_s)
+ print "warmiters:", times
+
+
+ return 0
+
+if __name__ == '__main__':
+ import sys
+ main(sys.argv[1:])
diff --git a/multithread/skiplist/skiplist.py b/multithread/skiplist/skiplist.py
--- a/multithread/skiplist/skiplist.py
+++ b/multithread/skiplist/skiplist.py
@@ -1,8 +1,9 @@
+
# https://github.com/kunigami/blog-examples/tree/master/2012-09-23-skip-list
from common.abstract_threading import (atomic, Future,
set_thread_pool, ThreadPool,
- print_abort_info, hint_commit_soon)
+ hint_commit_soon)
import time, threading
import random
@@ -66,7 +67,7 @@
node.next[i] = update[i].next[i]
update[i].next[i] = node
self.len += 1
- hint_commit_soon()
+ #hint_commit_soon()
def remove(self, elem):
update = self.updateList(elem)
@@ -78,7 +79,7 @@
if self.head.next[i] == None:
self.maxHeight -= 1
self.len -= 1
- hint_commit_soon()
+ #hint_commit_soon()
def printList(self):
for i in range(len(self.head.next)-1, -1, -1):
@@ -90,7 +91,7 @@
CONFLICTING = [SkipList.insert, SkipList.remove]
-OPS = [SkipList.find] * 98 + CONFLICTING
+OPS = [SkipList.find] * 198 + CONFLICTING
ITEM_RANGE = 1000000
def task(id, slist, ops):
@@ -119,7 +120,7 @@
-def run(threads=2, operations=2000000):
+def run(threads=2, concurrency=8, operations=2000000):
threads = int(threads)
operations = int(operations)
@@ -130,10 +131,10 @@
for _ in xrange(1000):
slist.insert(random.randint(1, ITEM_RANGE))
- c_len = operations // threads
+ c_len = operations // concurrency
fs = []
parallel_time = time.time()
- for i in xrange(threads):
+ for i in xrange(concurrency):
fs.append(Future(task, i, slist, c_len))
for f in fs:
f()
@@ -149,7 +150,28 @@
+def main(argv):
+ # warmiters threads args...
+ warmiters = int(argv[0])
+ threads = int(argv[1])
+ cs, ops = int(argv[2]), int(argv[3])
+ print "params (iters, threads, concs, ops):", warmiters, threads, cs, ops
+
+ print "do warmup:"
+ for i in range(3):
+ print "iter", i, "time:", run(threads, cs, ops)
+
+ print "turn off jitting"
+ import gc
+ turn_jitting_off()
+ print "do", warmiters, "real iters:"
+ times = []
+ for i in range(warmiters):
+ gc.collect()
+ times.append(run(threads, cs, ops))
+ print "warmiters:", times
if __name__ == '__main__':
- run()
+ import sys
+ main(sys.argv[1:])
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
