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)