def __init__(self, raw_mem, cpu, path_mgr):
self.raw_mem = raw_mem
self.ram_size = raw_mem.ram_size
self.cpu = cpu
self.path_mgr = path_mgr
# create a label manager and error tracker
self.label_mgr = LabelManager()
self.error_tracker = ErrorTracker(cpu, self.label_mgr)
self.label_mgr.error_tracker = self.error_tracker
# set a label for first two dwords
label = LabelRange("zero_page",0,8)
self.label_mgr.add_label(label)
# create memory access
self.mem = MainMemory(self.raw_mem, self.error_tracker)
self.mem.ctx = self
# create memory allocator
self.mem_begin = 0x1000
self.alloc = MemoryAlloc(self.mem, 0, self.ram_size, self.mem_begin, self.label_mgr)
# create segment loader
self.seg_loader = SegmentLoader( self.mem, self.alloc, self.label_mgr, self.path_mgr )
# lib manager
self.lib_mgr = LibManager( self.label_mgr )
# no current process right now
self.process = None
self.proc_list = []
self.tr_list = []
def __init__(self, raw_mem, cpu, traps, cfg):
self.raw_mem = raw_mem
self.ram_size = raw_mem.get_ram_size() * 1024 # in bytes
self.cpu = cpu
self.cpu_type = cfg.cpu
self.traps = traps
self.cfg = cfg
#sys.settrace(Tracer().traceit)
# too much RAM requested?
# our "custom chips" start at $BFxxxx so we allow RAM only to be below
if self.ram_size >= 0xbf0000 and self.cfg.hw_access != "disable":
raise VamosConfigError(
"Too much RAM configured! Only up to $BF0000 allowed.")
# setup custom chips
if self.cfg.hw_access != "disable":
self.hw_access = HardwareAccess(raw_mem)
self._setup_hw_access()
# path manager
self.path_mgr = PathManager(cfg)
# create a label manager and error tracker
if self.cfg.label_mgr != "disable":
self.label_mgr = LabelManager()
else:
self.label_mgr = None
self.error_tracker = ErrorTracker(cpu, self.label_mgr)
if self.label_mgr != None:
self.label_mgr.error_tracker = self.error_tracker
# set a label for first two dwords
if self.label_mgr != None:
label = LabelRange("zero_page", 0, 8)
self.label_mgr.add_label(label)
# create memory access
self.mem = MainMemory(raw_mem, self.error_tracker)
self.mem.ctx = self
self._setup_memory(raw_mem)
# create memory allocator
self.mem_begin = 0x1000
self.alloc = MemoryAlloc(self.mem, 0, self.ram_size, self.mem_begin,
self.label_mgr)
# create segment loader
self.seg_loader = SegmentLoader(self.mem, self.alloc, self.label_mgr,
self.path_mgr)
# lib manager
self.lib_mgr = LibManager(self.label_mgr, cfg)
# no current process right now
self.process = None
self.proc_list = []
def __init__(self, hilillos_to_run, quantum):
self.__pcb = PCBDataStructure()
self.threads_barrier = Barrier(2)
self.__dead_barrier = False
self.__killing_lock = Lock() # Lock used to kill the barrier
self.__waiting_lock = Lock()
self.__system_main_memory = MainMemory(self.__pcb, hilillos_to_run)
self.__simulation_statistics = SimulationStatistics()
self.__core0 = Core(0, self)
self.__core1 = Core(1, self)
self.__core_count = 2
self.running_cores = 2
self.__system_clock = 0
self.__default_quantum = quantum
self.__core_finished = False
self.__core_finished_counter = 0
# Data buss, instruction buss, cache 0, cache 1
self.__locks = [Lock(), Lock(), Lock(), Lock()]
self.__lock_owner = [-1, -1, -1, -1]
def __init__(self):
self.memory = MainMemory()
self.registers = Registers()
# If we have a second #, check the same things
if len(byte) == 4:
if byte[3].isalpha():
if byte[3].upper() > 'F':
return False
elif not byte[3].isdigit():
return False
return True
# Start the simulator, initialize the physical memory with bytes in hexadecimal provided in input.txt
print("*** Welcome to the cache simulator ***")
print("initialize the RAM:")
print("init-ram 0x00 0xFF")
ourRam = MainMemory()
ourRam.readFromFile(sys.argv[1])
print("ram successfully initialized!")
# Get values from user on cache specifics (check validity)
print("configure the cache:")
# C
cacheSize = input("cache size: ")
if not isCorrectInput(cacheSize, 8, 256):
sys.exit("Invalid cache size!")
# B
blockSize = input("data block size: ")
if not isCorrectInput(blockSize, 1, int(cacheSize)):
sys.exit("Invalid block size!")
