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"]
