def _create_hash(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
seed = parser.get_argument(lexer, args, 'seed', 7)
count = parser.get_argument(lexer, args, 'count', 65536)
input_port = parser.get_argument(lexer, args, 'input_port', -1)
output_port = parser.get_argument(lexer, args, 'output_port', -1)
return Hash(index, seed, count, input_port, output_port)
def parse_machine(lexer):
args = parser.parse_arguments(lexer)
addr_bits = parser.get_argument(lexer, args, 'addr_bits', 32)
frequency = parser.get_argument(lexer, args, 'frequency', 1e9)
technology = parser.get_argument(lexer, args, 'technology', 0.045)
part = parser.get_argument(lexer, args, 'part', 'xc7v585t')
max_path = parser.get_argument(lexer, args, 'max_path', 64)
max_cost = parser.get_argument(lexer, args, 'max_cost', 10000)
max_luts = parser.get_argument(lexer, args, 'max_luts', 10000)
max_regs = parser.get_argument(lexer, args, 'max_regs', 10000)
tstr = parser.get_argument(lexer, args, 'target', 'simple')
gstr = parser.get_argument(lexer, args, 'goal', 'access_time')
target = parse_target(tstr)
if target is None:
lex.ParseError(lexer, 'invalid target: ' + tstr)
goal = parse_goal(gstr)
if goal is None:
lex.ParseError(lexer, 'invalid goal: ' + gstr)
return MachineType(target=target,
goal=goal,
frequency=frequency,
addr_bits=addr_bits,
max_path_length=max_path,
max_cost=max_cost,
max_luts=max_luts,
max_regs=max_regs,
technology=technology,
part=part)
def _create_spm(lexer, args):
mem = parser.get_argument(lexer, args, 'memory')
word_size = parser.get_argument(lexer, args, 'word_size', 4)
size = parser.get_argument(lexer, args, 'size', 0)
access_time = parser.get_argument(lexer, args, 'access_time', 2)
cycle_time = parser.get_argument(lexer, args, 'cycle_time', access_time)
return SPM(mem, word_size, size, access_time, cycle_time)
def _create_heap(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
seed = parser.get_argument(lexer, args, 'seed', 7)
size = parser.get_argument(lexer, args, 'size', 1024)
input_port = parser.get_argument(lexer, args, 'input_port', -1)
output_port = parser.get_argument(lexer, args, 'output_port', -1)
return Heap(index, seed, size, input_port, output_port)
def _create_mm(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
size = parser.get_argument(lexer, args, 'size', 64)
iterations = parser.get_argument(lexer, args, 'iterations', 1)
input_port = parser.get_argument(lexer, args, 'input_port', -1)
output_port = parser.get_argument(lexer, args, 'output_port', -1)
return MM(index=index, size=size, iterations=iterations,
input_port=input_port, output_port=output_port)
def _create_option(lexer, args):
index = parser.get_argument(lexer, args, 'index', 0)
result = Option(index=index)
i = 0
while ('memory' + str(i)) in args:
result.add_option(args['memory' + str(i)])
i += 1
if i == 0:
raise lex.ParseError(lexer, "no memories in option")
return result
def _create_pca(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
size = parser.get_argument(lexer, args, 'size', 64)
count = parser.get_argument(lexer, args, 'count', 16)
iterations = parser.get_argument(lexer, args, 'iterations', 1)
input_port = parser.get_argument(lexer, args, 'input_port', -1)
output_port = parser.get_argument(lexer, args, 'output_port', -1)
return PCA(index, size, count, iterations, input_port, output_port)
def _create_fifo(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
word_size = parser.get_argument(lexer, args, 'word_size', 4)
depth = parser.get_argument(lexer, args, 'depth', 1)
bram = parser.get_argument(lexer, args, 'bram', True)
min_depth = parser.get_argument(lexer, args, 'min_depth', 1)
mem = parser.get_argument(lexer, args, 'memory')
return FIFO(index=index, mem=mem, depth=depth, min_depth=min_depth,
bram=bram, word_size=word_size)
def _create_cache(lexer, args):
line_count = parser.get_argument(lexer, args, 'line_count', 1)
line_size = parser.get_argument(lexer, args, 'line_size', 8)
associativity = parser.get_argument(lexer, args, 'associativity', 1)
access_time = parser.get_argument(lexer, args, 'access_time', 1)
cycle_time = parser.get_argument(lexer, args, 'cycle_time', access_time)
policy_str = parser.get_argument(lexer, args, 'policy', 'lru')
policy = parse_policy(lexer, policy_str)
write_back = parser.get_argument(lexer, args, 'write_back', True)
mem = parser.get_argument(lexer, args, 'memory')
return Cache(mem=mem,
line_count=line_count,
line_size=line_size,
associativity=associativity,
access_time=access_time,
cycle_time=cycle_time,
policy=policy,
write_back=write_back)
def _create_dram(lexer, args):
frequency = parser.get_argument(lexer, args, 'frequency', 666666667)
cas_cycles = parser.get_argument(lexer, args, 'cas_cycles', 10)
rcd_cycles = parser.get_argument(lexer, args, 'rcd_cycles', 10)
rp_cycles = parser.get_argument(lexer, args, 'rp_cycles', 10)
wb_cycles = parser.get_argument(lexer, args, 'wb_cycles', 0)
page_size = parser.get_argument(lexer, args, 'page_size', 1024)
page_count = parser.get_argument(lexer, args, 'page_count', 65536)
width = parser.get_argument(lexer, args, 'width', 8)
burst_size = parser.get_argument(lexer, args, 'burst_size', 4)
extra_cycles = parser.get_argument(lexer, args, 'extra', 1.0)
open_page = parser.get_argument(lexer, args, 'open_page', True)
ddr = parser.get_argument(lexer, args, 'ddr', True)
multiplier = parser.get_argument(lexer, args, 'multiplier', 1.0)
return DRAM(frequency=frequency,
cas_cycles=cas_cycles,
rcd_cycles=rcd_cycles,
rp_cycles=rp_cycles,
wb_cycles=wb_cycles,
page_size=page_size,
page_count=page_count,
width=width,
burst_size=burst_size,
extra_cycles=extra_cycles,
open_page=open_page,
ddr=ddr,
multiplier=multiplier)
def _create_prefetch(lexer, args):
mem = parser.get_argument(lexer, args, 'memory')
stride = parser.get_argument(lexer, args, 'stride', 0)
return Prefetch(mem, stride)
def _create_cholesky(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
size = parser.get_argument(lexer, args, 'size', 128)
input_port = parser.get_argument(lexer, args, 'input_port', -1)
output_port = parser.get_argument(lexer, args, 'output_port', -1)
return Cholesky(index, size, input_port, output_port)
def _create_xor(lexer, args):
value = parser.get_argument(lexer, args, 'value', 0)
mem = parser.get_argument(lexer, args, 'memory')
bank = parser.get_argument(lexer, args, 'bank')
return XOR(bank, mem, value)
def _create_ram(lexer, args):
word_size = parser.get_argument(lexer, args, 'word_size', 4)
latency = parser.get_argument(lexer, args, 'latency', 100)
burst = parser.get_argument(lexer, args, 'burst', 0)
return RAM(word_size, latency, burst)
def _create_split(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
in_port = parser.get_argument(lexer, args, 'in', 0)
out0 = parser.get_argument(lexer, args, 'out0', 0)
out1 = parser.get_argument(lexer, args, 'out1', 0)
return Split(index, in_port, out0, out1)
def _create_split(lexer, args):
offset = parser.get_argument(lexer, args, 'offset', 0)
mem = parser.get_argument(lexer, args, 'memory')
bank0 = parser.get_argument(lexer, args, 'bank0')
bank1 = parser.get_argument(lexer, args, 'bank1')
return Split(bank0, bank1, mem, offset)
def _create_main(lexer, args):
if parser.has_argument(lexer, args, 'memory'):
return parser.get_argument(lexer, args, 'memory')
else:
return None
def _create_trace(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
name = parser.get_argument(lexer, args, 'name', 'input')
last = parser.get_argument(lexer, args, 'last', False)
return Trace(index, name, last)
def _create_maze(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
width = parser.get_argument(lexer, args, 'width', 32)
height = parser.get_argument(lexer, args, 'height', 32)
seed = parser.get_argument(lexer, args, 'seed', 5)
return Maze(index, width, height, seed)
def _create_subsystem(lexer, args):
index = parser.get_argument(lexer, args, 'id', 0)
word_size = parser.get_argument(lexer, args, 'word_size', 4)
depth = parser.get_argument(lexer, args, 'depth', -1)
mem = parser.get_argument(lexer, args, 'memory')
return Subsystem(word_size=word_size, index=index, depth=depth, mem=mem)
def _create_offset(lexer, args):
offset = parser.get_argument(lexer, args, 'value', 0)
mem = parser.get_argument(lexer, args, 'memory')
bank = parser.get_argument(lexer, args, 'bank')
return Offset(bank, mem, offset)
