[pypy-svn] r15545 - pypy/dist/pypy/translator/llvm2/demo
rxe at codespeak.net
rxe at codespeak.net
Wed Aug 3 11:03:35 CEST 2005
Author: rxe
Date: Wed Aug 3 11:03:33 2005
New Revision: 15545
Added:
pypy/dist/pypy/translator/llvm2/demo/
pypy/dist/pypy/translator/llvm2/demo/bpnn.py
pypy/dist/pypy/translator/llvm2/demo/richards.py
Log:
Add modified versions of bpnn and richard.
Added: pypy/dist/pypy/translator/llvm2/demo/bpnn.py
==============================================================================
--- (empty file)
+++ pypy/dist/pypy/translator/llvm2/demo/bpnn.py Wed Aug 3 11:03:33 2005
@@ -0,0 +1,271 @@
+#!/usr/bin/python
+"""
+ Translator Demo
+
+ Run this file -- over regular Python! -- to analyse and type-annotate
+ the functions and class defined in this module, starting from the
+ entry point function demo().
+
+ Requires Pygame.
+"""
+# Back-Propagation Neural Networks
+#
+# Written in Python. See http://www.python.org/
+#
+# Neil Schemenauer <nascheme at enme.ucalgary.ca>
+#
+# Modifications to the original (Armin Rigo):
+# * import random from PyPy's lib, which is Python 2.2's plain
+# Python implementation
+# * starts the Translator instead of the demo by default.
+
+import sys
+import math
+import time
+import os, time
+
+# XXX the Translator needs the plain Python version of random.py:
+from pypy.lib import random
+
+PRINT_IT = False
+
+random.seed(0)
+
+# calculate a random number where: a <= rand < b
+def rand(a, b):
+ return (b-a)*random.random() + a
+
+# Make a matrix (we could use NumPy to speed this up)
+def makeMatrix(I, J, fill=0.0):
+ m = []
+ for i in range(I):
+ m.append([fill]*J)
+ return m
+
+class NN:
+
+ def __init__(self, ni, nh, no):
+ # number of input, hidden, and output nodes
+ self.ni = ni + 1 # +1 for bias node
+ self.nh = nh
+ self.no = no
+
+ # activations for nodes
+ self.ai = [1.0] * self.ni
+ self.ah = [1.0] * self.nh
+ self.ao = [1.0] * self.no
+
+ # create weights
+ self.wi = makeMatrix(self.ni, self.nh)
+ self.wo = makeMatrix(self.nh, self.no)
+ # set them to random vaules
+ for i in range(self.ni):
+ for j in range(self.nh):
+ self.wi[i][j] = rand(-2.0, 2.0)
+ for j in range(self.nh):
+ for k in range(self.no):
+ self.wo[j][k] = rand(-2.0, 2.0)
+
+ # last change in weights for momentum
+ self.ci = makeMatrix(self.ni, self.nh)
+ self.co = makeMatrix(self.nh, self.no)
+
+ def update(self, inputs):
+ if len(inputs) != self.ni-1:
+ raise ValueError, 'wrong number of inputs'
+
+ # input activations
+ i = 0
+ while i < self.ni-1:
+ #self.ai[i] = 1.0/(1.0+math.exp(-inputs[i]))
+ self.ai[i] = inputs[i]
+ i += 1
+
+ # hidden activations
+ j = 0
+ while j < self.nh:
+ sum = 0.0
+ i = 0
+ while i < self.ni:
+ sum = sum + self.ai[i] * self.wi[i][j]
+ i += 1
+ self.ah[j] = 1.0/(1.0+math.exp(-sum))
+ j += 1
+
+ # output activations
+ k = 0
+ while k < self.no:
+ sum = 0.0
+ for j in range(self.nh):
+ sum = sum + self.ah[j] * self.wo[j][k]
+ self.ao[k] = 1.0/(1.0+math.exp(-sum))
+ k += 1
+
+ return self.ao[:]
+
+ def backPropagate(self, targets, N, M):
+ if len(targets) != self.no:
+ raise ValueError, 'wrong number of target values'
+
+ # calculate error terms for output
+ output_deltas = [0.0] * self.no
+ k = 0
+ while k < self.no:
+ ao = self.ao[k]
+ output_deltas[k] = ao*(1-ao)*(targets[k]-ao)
+ k += 1
+
+ # calculate error terms for hidden
+ hidden_deltas = [0.0] * self.nh
+ j = 0
+ while j < self.nh:
+ sum = 0.0
+ k = 0
+ while k < self.no:
+ sum = sum + output_deltas[k]*self.wo[j][k]
+ k += 1
+ hidden_deltas[j] = self.ah[j]*(1-self.ah[j])*sum
+ j += 1
+
+ # update output weights
+ j = 0
+ while j < self.nh:
+ k = 0
+ while k < self.no:
+ change = output_deltas[k]*self.ah[j]
+ self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k]
+ self.co[j][k] = change
+ k += 1
+ j += 1
+ #print N*change, M*self.co[j][k]
+
+ # update input weights
+ i = 0
+ while i < self.ni:
+ j = 0
+ while j < self.nh:
+ change = hidden_deltas[j]*self.ai[i]
+ self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j]
+ self.ci[i][j] = change
+ j += 1
+ i += 1
+
+ # calculate error
+ error = 0.0
+ k = 0
+ while k < len(targets):
+ error = error + 0.5*(targets[k]-self.ao[k])**2
+ k += 1
+ return error
+
+
+ def xtest(self, patterns):
+ for p in patterns:
+ #if PRINT_IT:
+ os.write(1, "[%d, %d] '->' " % (p[0][0], p[0][1]))
+ for ii in self.update(p[0]):
+ os.write(1, "%d " % int(ii * 1000))
+ os.write(1, " \n")
+
+ def weights(self):
+ if PRINT_IT:
+ print 'Input weights:'
+ for i in range(self.ni):
+ print self.wi[i]
+ print
+ print 'Output weights:'
+ for j in range(self.nh):
+ print self.wo[j]
+
+ def train(self, patterns, iterations=2000, N=0.5, M=0.1):
+ # N: learning rate
+ # M: momentum factor
+ i = 0
+ while i < iterations:
+ error = 0.0
+ for p in patterns:
+ inputs = p[0]
+ targets = p[1]
+ self.update(inputs)
+ error = error + self.backPropagate(targets, N, M)
+ if PRINT_IT and i % 100 == 0:
+ print 'error %f' % error
+ i += 1
+
+def demo():
+ # Teach network XOR function
+ pat = [
+ [[0,0], [0]],
+ [[0,1], [1]],
+ [[1,0], [1]],
+ [[1,1], [0]]
+ ]
+
+ # create a network with two input, two hidden, and two output nodes
+ n = NN(2, 3, 1)
+ # train it with some patterns
+ n.train(pat, 2000)
+ # test it
+ n.xtest(pat)
+ return 0
+#_________________________________________________________
+
+from pypy.translator.llvm2.genllvm import compile_function
+import py
+
+def test_demo():
+ py.log.setconsumer("genllvm", py.log.STDOUT)
+ py.log.setconsumer("genllvm database prepare", None)
+ f = compile_function(demo, [])
+
+ print 'Running...'
+ T = time.time()
+ for i in range(10):
+ f()
+ t1 = time.time() - T
+ print "that took", t1
+
+ T = time.time()
+ for i in range(10):
+ demo()
+ t2 = time.time() - T
+ print "compared to", t2
+ print "a speed-up of", t2/t1
+
+def main():
+ T = time.time()
+ os.write(1, 'Running...\n')
+
+ for i in range(50):
+ demo()
+
+ t1 = time.time() - T
+ os.write(1, 'That took... %d msecs \n' % int(t1 * 1000))
+ return 0
+
+if __name__ == "__main__":
+ from pypy.translator.llvm2.genllvm import compile_function
+ import py
+
+ import sys
+ compile_llvm = True
+ if len(sys.argv) > 1:
+ if sys.argv[1] == "p":
+ main()
+ compile_llvm = False
+ elif sys.argv[1] == "c":
+
+ from pypy.translator.translator import Translator
+ t = Translator(main)
+ a = t.annotate([])
+ t.specialize()
+ f = t.ccompile()
+ f()
+
+ compile_llvm = False
+
+ if compile_llvm:
+ compile_function(main, [])
+
+ # run with the following command
+ "llvmc -Tasm=-enable-correct-eh-support -v -L /usr/lib/ -lm -lgc main_optimized.bc -o go"
Added: pypy/dist/pypy/translator/llvm2/demo/richards.py
==============================================================================
--- (empty file)
+++ pypy/dist/pypy/translator/llvm2/demo/richards.py Wed Aug 3 11:03:33 2005
@@ -0,0 +1,446 @@
+
+# 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
+
+# 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:
+ 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:
+ 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:
+ 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:
+ def __init__(self):
+ self.taskTab = [None] * TASKTABSIZE
+
+ self.taskList = None
+
+ self.holdCount = 0
+ self.qpktCount = 0
+
+taskWorkArea = TaskWorkArea()
+
+class Task(TaskState):
+
+
+ def __init__(self,i,p,w,initialState,r):
+ 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):
+ 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)
+ taskWorkArea.qpktCount += 1
+ pkt.link = None
+ pkt.ident = self.ident
+ return t.addPacket(pkt,self)
+
+
+ def findtcb(self,id):
+ t = 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):
+ Task.__init__(self,i,p,w,s,r)
+
+ 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):
+ Task.__init__(self,i,p,w,s,r)
+
+ 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):
+ Task.__init__(self,i,0,None,s,r)
+
+ 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):
+ Task.__init__(self,i,p,w,s,r)
+
+ 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)
+
+import time
+
+
+
+def schedule():
+ 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:
+
+ iterations = 25
+
+ def run(self):
+ for i in xrange(self.iterations):
+ taskWorkArea.holdCount = 0
+ taskWorkArea.qpktCount = 0
+
+ IdleTask(I_IDLE, 1, 10000, TaskState().running(), IdleTaskRec())
+
+ wkq = Packet(None, 0, K_WORK)
+ wkq = Packet(wkq , 0, K_WORK)
+ WorkTask(I_WORK, 1000, wkq, TaskState().waitingWithPacket(), WorkerTaskRec())
+
+ 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())
+
+ 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())
+
+ wkq = None;
+ DeviceTask(I_DEVA, 4000, wkq, TaskState().waiting(), DeviceTaskRec());
+ DeviceTask(I_DEVB, 5000, wkq, TaskState().waiting(), DeviceTaskRec());
+
+ schedule()
+
+ if taskWorkArea.holdCount == 9297 and taskWorkArea.qpktCount == 23246:
+ pass
+ else:
+ return False
+
+ return True
+
+def entry_point():
+ r = Richards()
+ startTime = time.time()
+ result = r.run()
+ endTime = time.time()
+ return result, startTime, endTime
+
+def main():
+ import os
+ os.write(1, "Richards benchmark (Python) starting... \n")
+ result, startTime, endTime = entry_point()
+ if not result:
+ os.write(1, "Incorrect results!\n")
+ return 1
+ os.write(1, "finished.\n")
+ total_s = endTime - startTime
+ os.write(1, "\nTotal time for %d iterations: %d msecs\n" %(Richards.iterations, int(1000 * total_s)))
+ os.write(1, "Average time for iterations: %d ms\n" % (int(total_s * 1000)/Richards.iterations))
+ return 0
+
+if __name__ == "__main__":
+ from pypy.translator.llvm2.genllvm import compile_function
+ import py
+
+ import sys
+ compile_llvm = True
+ if len(sys.argv) > 1:
+ if sys.argv[1] == "p":
+ main()
+ compile_llvm = False
+ elif sys.argv[1] == "c":
+
+ from pypy.translator.translator import Translator
+ t = Translator(main)
+ a = t.annotate([])
+ t.specialize()
+ f = t.ccompile()
+ f()
+
+ compile_llvm = False
+
+ if compile_llvm:
+ compile_function(main, [])
+
+ # run with the following command
+ "llvmc -Tasm=-enable-correct-eh-support -v -L /usr/lib/ -lm -lgc main_optimized.bc -o go"
More information about the Pypy-commit
mailing list