47a48
> import MemConfig
78,81d78
< # ruby sparse memory options
< parser.add_option("--use-map", action="store_true", default=False)
< parser.add_option("--map-levels", type="int", default=4)
<
88,89d84
< parser.add_option("--ruby_stats", type="string", default="ruby.stats")
<
93a89,139
> def setup_memory_controllers(system, ruby, dir_cntrls, options):
> ruby.block_size_bytes = options.cacheline_size
> ruby.memory_size_bits = 48
> block_size_bits = int(math.log(options.cacheline_size, 2))
>
> if options.numa_high_bit:
> numa_bit = options.numa_high_bit
> else:
> # if the numa_bit is not specified, set the directory bits as the
> # lowest bits above the block offset bits, and the numa_bit as the
> # highest of those directory bits
> dir_bits = int(math.log(options.num_dirs, 2))
> numa_bit = block_size_bits + dir_bits - 1
>
> index = 0
> mem_ctrls = []
> crossbars = []
>
> # Sets bits to be used for interleaving. Creates memory controllers
> # attached to a directory controller. A separate controller is created
> # for each address range as the abstract memory can handle only one
> # contiguous address range as of now.
> for dir_cntrl in dir_cntrls:
> dir_cntrl.directory.numa_high_bit = numa_bit
>
> crossbar = None
> if len(system.mem_ranges) > 1:
> crossbar = NoncoherentXBar()
> crossbars.append(crossbar)
> dir_cntrl.memory = crossbar.slave
>
> for r in system.mem_ranges:
> mem_ctrl = MemConfig.create_mem_ctrl(
> MemConfig.get(options.mem_type), r, index, options.num_dirs,
> int(math.log(options.num_dirs, 2)), options.cacheline_size)
>
> mem_ctrls.append(mem_ctrl)
>
> if crossbar != None:
> mem_ctrl.port = crossbar.master
> else:
> mem_ctrl.port = dir_cntrl.memory
>
> index += 1
>
> system.mem_ctrls = mem_ctrls
>
> if len(crossbars) > 0:
> ruby.crossbars = crossbars
>
>
106c152
< system.ruby = RubySystem(no_mem_vec = options.use_map)
---
> system.ruby = RubySystem()
172,178c218
< # Loop through the directory controlers.
< # Determine the total memory size of the ruby system and verify it is equal
< # to physmem. However, if Ruby memory is using sparse memory in SE
< # mode, then the system should not back-up the memory state with
< # the Memory Vector and thus the memory size bytes should stay at 0.
< # Also set the numa bits to the appropriate values.
< total_mem_size = MemorySize('0B')
---
> setup_memory_controllers(system, ruby, dir_cntrls, options)
180,199d219
< ruby.block_size_bytes = options.cacheline_size
< block_size_bits = int(math.log(options.cacheline_size, 2))
<
< if options.numa_high_bit:
< numa_bit = options.numa_high_bit
< else:
< # if the numa_bit is not specified, set the directory bits as the
< # lowest bits above the block offset bits, and the numa_bit as the
< # highest of those directory bits
< dir_bits = int(math.log(options.num_dirs, 2))
< numa_bit = block_size_bits + dir_bits - 1
<
< for dir_cntrl in dir_cntrls:
< total_mem_size.value += dir_cntrl.directory.size.value
< dir_cntrl.directory.numa_high_bit = numa_bit
<
< phys_mem_size = sum(map(lambda r: r.size(), system.mem_ranges))
< assert(total_mem_size.value == phys_mem_size)
< ruby.mem_size = total_mem_size
<