def visitBopConv(self, node:AST.BOp, args=None): (prog1, expr1) = self.visit(node.expr1) (prog2, expr2) = self.visit(node.expr2) [N , H , W , CI] = node.expr1.type.shape [FH, FW, CI, CO] = node.expr2.type.shape returnExpr = self.getTempVar() comment = IR.Comment(expr1.idf + ' # ' + expr2.idf) funcCallArgsDict = OrderedDict() funcCallArgsDict[IR.Int(N, 32)] = "N" funcCallArgsDict[IR.Int(H, 32)] = "H" funcCallArgsDict[IR.Int(W, 32)] = "W" funcCallArgsDict[IR.Int(CI, 32)] = "CI" funcCallArgsDict[IR.Int(FH, 32)] = "FH" funcCallArgsDict[IR.Int(FW, 32)] = "FW" funcCallArgsDict[IR.Int(CO, 32)] = "CO" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadHLeft], 32)] = "zPadHLeft" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadHRight], 32)] = "zPadHRight" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadWLeft], 32)] = "zPadWLeft" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadWRight], 32)] = "zPadWRight" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.strideH], 32)] = "strideH" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.strideW], 32)] = "strideW" funcCallArgsDict[expr1] = "input" funcCallArgsDict[expr2] = "filter" funcCallArgsDict[IR.Int(Util.Config.consSF, 32)] = "consSF" funcCallArgsDict[returnExpr] = "output" funcCall = IR.FuncCall("Conv2DCSF", funcCallArgsDict) progConv = IR.Prog([comment, funcCall]) returnProg = IRUtil.prog_merge(prog1, prog2, progConv) self.decls[returnExpr.idf] = [node.type] returnProg = IRUtil.prog_merge(IR.Prog([IR.Decl(returnExpr.idf, node.type)]), returnProg) return (returnProg, returnExpr)
def getTempVar(self): var = IR.Var('tmp' + str(self._var_cnt)) self._var_cnt += 1 return var
def visitReshape(self, node:AST.Reshape, args=None): (prog_1, expr_1) = self.visit(node.expr) ''' reshape(A, n, h, w) cmd1: t1 = t2 = t3 = 0; loop2: for n in 0:N: for h in 0:H: for w in 0:W: cmd3: B[n][h][w] = A[t1][t2][t3] cmd4: t3++; cmd5: if (t3 == WW) t3 = 0; t2++; if (t2 == HH) t2 = 0; t1++; ''' typ_1 = node.expr.type typ_2 = node.type # Declare variables expr_2 = self.getTempVar() iters_1 = self.getTempIterators(typ_1.dim) iters_2 = self.getTempIterators(typ_2.dim) # Initialize to 0 cmd1 = [IR.Assn(var, IRUtil.zero) for var in iters_1] # Incrementing the first index first_iter = iters_1[0] cmd4 = IRUtil.incCmd(first_iter) # Incrementing other indices using a loop cmd5 = [cmd4] for i in range(1, typ_1.dim): curr_iter = iters_1[i] curr_size = IR.Int(typ_1.shape[i]) cmd5 = [IRUtil.incCmd(curr_iter), IR.If(IRUtil.eq(curr_iter, curr_size), [IRUtil.initVarToZero(curr_iter)] + cmd5)] # Outer loop loopShape = [] loopIters = [] if node.order: for order in node.order: order = order - 1 loopShape.append(typ_2.shape[order]) loopIters.append(iters_2[order]) else: loopShape = typ_2.shape loopIters = iters_2 loop2 = IRUtil.loop(loopShape, loopIters, [IR.Assn(IRUtil.addIndex(expr_2, iters_2), IRUtil.addIndex(expr_1, iters_1))] + cmd5) # Finalize comment1 = IR.Comment(str(node.metadata)) comment2 = IR.Comment("reshape(" + expr_1.idf + ", " + ', '.join(str(e) for e in typ_2.shape) + ")") reshape_prog = IR.Prog([comment1, comment2] + cmd1 + loop2) prog_2 = IRUtil.prog_merge(prog_1, reshape_prog) # Update context self.decls[expr_2.idf] = [typ_2] # Update declarations self.decls.update(dict((var.idf, [Type.Int(), 'public']) for var in iters_1)) self.decls.update(dict((var.idf, [Type.Int(), 'public']) for var in iters_2)) for var in iters_1: prog_2 = IRUtil.prog_merge(IR.Prog([IR.Decl(var.idf, Type.Int(), isSecret="public")]), prog_2) for var in iters_2: prog_2 = IRUtil.prog_merge(IR.Prog([IR.Decl(var.idf, Type.Int(), isSecret="public")]), prog_2) prog_2 = IRUtil.prog_merge(IR.Prog([IR.Decl(expr_2.idf, typ_2)]), prog_2) return (prog_2, expr_2)
def visitPool(self, node:AST.Pool, args=None): (prog_1, expr_1) = self.visit(node.expr) [N, H, W, CI] = node.expr.type.shape [N1, outH, outW, CI1] = node.type.shape assert(N==N1 and CI==CI1) [expr_2] = self.getTempVars(1) comment = IR.Comment(str(node.metadata)) funcCallArgsDict = OrderedDict() funcCallArgsDict[IR.Int(N1, 32)] = "N1" funcCallArgsDict[IR.Int(outH, 32)] = "outH" funcCallArgsDict[IR.Int(outW, 32)] = "outW" funcCallArgsDict[IR.Int(CI1, 32)] = "CI1" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.FH], 32)] = "FH" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.FW], 32)] = "FW" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadHLeft], 32)] = "zPadHLeft" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadHRight], 32)] = "zPadHRight" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadWLeft], 32)] = "zPadWLeft" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.zPadWRight], 32)] = "zPadWRight" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.strideH], 32)] = "strideH" funcCallArgsDict[IR.Int(node.options[AST.PaddingKeysDict.strideW], 32)] = "strideW" funcCallArgsDict[IR.Int(N, 32)] = "N" funcCallArgsDict[IR.Int(H, 32)] = "H" funcCallArgsDict[IR.Int(W, 32)] = "W" funcCallArgsDict[IR.Int(CI, 32)] = "CI" funcCallArgsDict[expr_1] = "input" funcCallArgsDict[expr_2] = "output" funcCall = IR.FuncCall(node.poolType, funcCallArgsDict) prog_pool = IR.Prog([comment, funcCall]) prog_2 = IRUtil.prog_merge(prog_1, prog_pool) self.decls[expr_2.idf] = [node.type] prog_2 = IRUtil.prog_merge(IR.Prog([IR.Decl(expr_2.idf, node.type)]), prog_2) return (prog_2, expr_2)
def visitId(self, node:AST.ID, args=None): idf = node.name prog = IR.Prog([]) expr = IR.Var(idf) return (prog, expr)
# finally sort the `leaders` self._leaders.sort() def addLeader(self, leader): """Add a new leader Adds a new leader to leaders lists, check for duplications before adding Arguments: leader {int} -- The new leader to be added """ try: leader = int(leader) except ValueError, e: # raise e x = e else: # if leader is already not present in leaders, add it, else... if not leader in self._leaders: self._leaders.append(leader) if __name__ == '__main__': ir = IR("./../test/gcd.ir") tac = ir.tac bbGen = BBGen(tac) print bbGen._leaders print bbGen._fns
# and take this special case, where we set function parameters to live # untill function is get called elif tac.type == InstrType.params: funcCallAt = currLine + 1 while tac.type == InstrType.params: if "const_" not in tac.src["type"]: symbolTable[currLine][tac.src["place"]] = [ 1, funcCallAt + 1 ] currLine -= 1 tac = bbNode[currLine] continue # now update the necessary variables for src in activeVars: symbolTable[currLine][src] = [ 1, currLine + 1 ] # set next use to current line and live currLine -= 1 return symbolTable, nonTempVars if __name__ == '__main__': ir = IR("sample_input.ir") tac = ir._tac fg = FlowGraph(ir.tac) blockNode = fg._blockNodes[4]._block print NextUseLive(blockNode, ir.symbolTable)
from IR import IR import tkinter as tk #################################### # Inisialisasi IR # Buka folder "deeplearning" ir = IR("deeplearning") def gui_query(): query = input_text_box.get("1.0", "end-1c") result = ir.query(query) result = [page[0] for page in result] output_text_box.delete("1.0", tk.END) [ output_text_box.insert(tk.END, str.format("\nHalaman : %d" % page)) for page in result ] #################################### # Buat GUI sederhana # GUI berupa # Input : Text Box # Search : Button # Output : Button ## Buat sebuah Window window = tk.Tk()
if var["scope"] == "global": loadIns = "lw " + reg + ", g_" + str(var["place"]).replace( "$", "_", 1) elif var["scope"] == "local": loadIns = "lw " + reg + ", " + str(var["offset"]) + "($sp)" else: loadIns = "lw " + reg + ", " + str(8 + var["offset"]) + "($fp)" return loadIns if __name__ == '__main__': fileName = "./../test/test1.ir" if len(sys.argv) == 2: fileName = sys.argv[1] ir = IR(fileName) code = CodeGen(ir) print "\t.text" print "\t.globl main\n" print "main:\n" codeBlocks = code._codeBlocks # add the library functions # Now add the generated block by code generator i = 1 for node in codeBlocks: print "B" + str(i) + ":" print "\t" + "\n\t".join(node) i += 1 print "\tj " + LibFns["exit"]