asm/logicCpu.py

   1 #!env python
   2 # Created:20080415
   3 # By Antonio Chavez
   4 #
   5 # 3-trit Computer Simulator
   6 # usage: logicCpu program.3
   7 # This program simulates the hardware of the 3 trit computer we are
   8 #    developing. Input to the program is a ".3" file which should contain
   9 #    three encoded instructions to simulate on the first line.  Once started,
  10 #    the user may interactively change the "IN" register at any time.
  11 #    Execution begins with instruction at program counter 0.
  12
  13 import sys, os, threading, time, signal
  14
  15 # for safe termination
  16 terminate_now = False
  17
  18 # for concurrency
  19 locked = False
  20
  21 TRACE = True
  22 DELAY = 1                   # second(s)
  23 USER_INPUT_THREAD = True    # ask for user input?
  24 USER_INPUT_INIT = 8         # initialize input to this
  25
  26 trit_integer = {"i": -1, "0":0, "1":1}
  27
  28 # Lookup a register's name by address
  29 register_name = {
  30         -1: "IN",
  31          0: "OUT",
  32          1: "A"
  33     }
  34
  35 # Register contents
  36 registers = {
  37         "IN":  0,
  38         "OUT": 0,
  39         "A":   0,
  40         "S":   1
  41     }
  42
  43 # Thread that gets input from user
  44 class CPUInput (threading.Thread):
  45     def run (self):
  46         global terminate_now
  47
  48         while True:
  49             print "Register Status: %s :" % registers,
  50
  51             try:
  52                 user_input = raw_input('Input value for IN:')
  53             except EOFError, e:
  54                 get_lock()
  55                 terminate_now = True
  56                 release_lock()
  57                 sys.exit()
  58
  59             get_lock()
  60             if terminate_now:
  61                 sys.exit()
  62             release_lock()
  63
  64             try:
  65                 digit = int(user_input)
  66             except ValueError, e:
  67                 print "invalid input: %s (%s)" % (user_input, e)
  68                 continue
  69
  70             if digit >= -4 and digit <= 4:
  71                 registers["IN"] = digit
  72             else:
  73                 print """invalid input: %s""" % user_input
  74
  75 def get_lock():
  76     ''' Busy wait lock to avoid race conditions.
  77         This function retrieves the lock.
  78     '''
  79     global locked
  80
  81     while locked:
  82         a = 1
  83     locked = True
  84
  85 def release_lock():
  86     ''' This function releases the lock.
  87     '''
  88     global locked
  89
  90     locked = False
  91
  92
  93 def main():
  94     global terminate_now
  95
  96     # check arguments
  97     if len(sys.argv) < 2 or len(sys.argv) > 2:
  98         print """usage: %s program.3
  99 input file: program.3 - machine code
 100 """ % (sys.argv[0])
 101         raise SystemExit
 102
 103     if (sys.argv[1])[len(sys.argv[1])-1:] != "3":
 104          print """\'%s\' is an invalid filetype""" % sys.argv[1]
 105          raise SystemExit
 106
 107     # retrieve file
 108     codefile = file(sys.argv[1], "rt")
 109     tritstream = codefile.readline()
 110
 111     # check for errors in file
 112     if codefile == []:
 113         print """\'%s\' files is empty""" % (sys.argv[1])
 114         raise SystemExit
 115
 116     for i in tritstream:
 117         if not i in trit_integer:
 118             print """invalid char \'%s\' in file \'%s\'""" % (i, sys.argv[1])
 119             raise SystemExit
 120
 121     if len(tritstream) != 9:
 122         print """3 instructions must be provided in \'%s\'""" % (sys.argv[1])
 123         raise SystemExit
 124
 125     # memory, registers, and program counter
 126     memory = {}
 127
 128     get_lock()
 129     registers["PC"] = 0
 130     release_lock()
 131
 132     # decode instructions from file
 133     for i in range(-1, 2):
 134         print "%2d: " % (i),
 135         memory[i] = Decoder(tritstream)
 136         tritstream = tritstream[3:]
 137
 138     # start user input thread
 139     if USER_INPUT_THREAD:
 140         CPUInput().start()
 141
 142     get_lock()
 143     registers["IN"] = USER_INPUT_INIT
 144     release_lock()
 145
 146     print "Press Ctrl-D to terminate"
 147     # execute instructions
 148     while True:
 149
 150         get_lock()
 151         registers["PC"] = Execute(memory)
 152         release_lock()
 153
 154         get_lock()
 155         if terminate_now:
 156             sys.exit()
 157         release_lock()
 158
 159         if TRACE:
 160             get_lock()
 161             print registers
 162             release_lock()
 163
 164         time.sleep(DELAY)
 165
 166 def Decoder(tritstream):
 167     """ Decode a single instruction.
 168         tristream: stream of trits will only process the first 3 trits.
 169         return: dictionary containing the operation
 170     """
 171     inst = {"op":trit_integer[tritstream[0]]}
 172
 173     # cmp and be
 174     if inst["op"] == -1 or inst["op"] == 1:
 175
 176         if inst["op"] == -1:
 177             print "cmp ",
 178         else:
 179             print "be  ",
 180
 181         inst["src1"] = trit_integer[tritstream[1]]
 182         print "%2d," % inst["src1"],
 183         inst["src2"] = trit_integer[tritstream[2]]
 184         print "%2d" % inst["src2"]
 185
 186     # lwi
 187     elif inst["op"] == 0:
 188         print "lwi ",
 189         inst["src1"] = trit_integer[tritstream[1]]
 190         inst["src2"] = trit_integer[tritstream[2]]
 191         inst["immed"] = 3*inst["src1"] + inst["src2"]
 192         print "%2d" % inst["immed"]
 193
 194     return inst
 195
 196 def Execute(memory):
 197     """ Execute one instruction.
 198         memory: were decoded instructions are stored
 199         registers: contains registers and their values
 200         returns: new program counter, to be stored in registers["PC"]
 201     """
 202
 203     op = (memory[registers["PC"]])["op"]
 204
 205     # cmp
 206     if op == -1:
 207         src1 = (memory[registers["PC"]])["src1"]
 208         src2 = (memory[registers["PC"]])["src2"]
 209         if registers[register_name[src1]] < registers[register_name[src2]]:
 210             registers["S"] = -1
 211         elif registers[register_name[src1]] > registers[register_name[src2]]:
 212             registers["S"] = 1
 213         else:
 214             registers["S"] = 0
 215         new_pc = registers["PC"] + 1
 216     # lwi
 217     elif op == 0:
 218         registers["A"] = (memory[registers["PC"]])["immed"]
 219         new_pc = registers["PC"] + 1
 220     # be
 221     elif op == 1:
 222         if registers["S"] == 0:
 223             new_pc = (memory[registers["PC"]])["src1"]
 224         else:
 225             new_pc = (memory[registers["PC"]])["src2"]
 226
 227     if new_pc > 1:
 228        new_pc = -1
 229
 230     return new_pc
 231
 232 if __name__ == "__main__":
 233     main()