def main():
number_of_operations = int(input('How many operations? '))
book = Book(Operations(Fifo()), number_of_operations)
while book.can_add_operation is not False:
book.add_operation(input('Input the operation: '))
for x in range(0, number_of_operations):
result = book.execute()
if result is not None:
print(result)
def test_should_the_ouput_equal_14():
book = Book(Operations(Fifo()), 4)
book.add_operation('1 80')
book.add_operation('1 14')
book.add_operation('2')
book.add_operation('3')
book.execute()
book.execute()
book.execute()
assert book.execute() == 14
def __init__(self, name, neighbors=None):
self.name = name
self.holder = None
self.using = False
self.request_q = Fifo()
self.asked = False
self.is_recovering = False
self.is_working = False
self.neighbors_states = {}
self.neighbors = neighbors if neighbors else []
self.consumer = Consumer(self.name, self._handle_message)
self.publisher = Publisher(self.name)
def init(pru_bin): pypruss.modprobe(1024) ddr_addr = pypruss.ddr_addr() ddr_size = pypruss.ddr_size() print "DDR memory address is 0x%x and the size is 0x%x"%(ddr_addr, ddr_size) fifo = Fifo(ddr_addr, ddr_size) pypruss.init() pypruss.open(0) pypruss.pruintc_init() pypruss.pru_write_memory(0,0,[ddr_addr]) pypruss.exec_program(0, pru_bin) return fifo
def kill(self):
"""
Simulates a node crash
Clears its state
Then call recover method
"""
self.holder = None
self.using = False
self.is_working = False
self.request_q = Fifo()
self.asked = False
self.neighbors_states = {}
self._recover()
def test_patience_time(self):
fifo = Fifo()
fifo.add_to_line(Patient("+", 2))
fifo.add_to_line(Patient("+", 3))
fifo.add_to_line(Patient("+", 5))
fifo.elapse_time()
self.assertEqual(1, fifo.get_next_patient().patience_in_minutes)
fifo.elapse_time()
fifo.elapse_time()
self.assertEqual(2, fifo.get_next_patient().patience_in_minutes)
self.assertEqual(0, len(fifo.line))
self.assertIsNone(fifo.get_next_patient())
def test_add_patients(self):
fifo = Fifo()
fifo.add_to_line(Patient("+", 3))
fifo.add_to_line(Patient("+", 6))
fifo.add_to_line(Patient("+", 1))
fifo.add_to_line(Patient("+", 2))
fifo.add_to_line(Patient("+", 4))
self.assertEqual(5, len(fifo.line))
fifo.elapse_time()
self.assertEqual(4, len(fifo.line))
fifo.elapse_time()
self.assertEqual(3, len(fifo.line))
fifo.elapse_time()
self.assertEqual(2, len(fifo.line))
fifo.elapse_time()
self.assertEqual(1, len(fifo.line))
fifo.elapse_time()
self.assertEqual(1, len(fifo.line))
fifo.elapse_time()
self.assertEqual(0, len(fifo.line))
def queue():
return Fifo()
import sys
from fifo import Fifo
from lru import LRU
from opt import Opt
def read_file(file_name):
with open(file_name, "r") as f:
result = map(lambda line: int(line.replace("\n", "")), f.readlines())
return result
if __name__ == "__main__":
args = sys.argv
slots = args[1]
file_name = args[2]
entries = list(read_file(file_name))
fifo = Fifo(int(slots))
lru = LRU(int(slots))
opt = Opt(int(slots), entries)
for index, entrie in enumerate(entries):
fifo.add(entrie)
lru.add(entrie)
opt.add(entrie, index)
print(
"{} quadros, {} refs: FIFO: {} PFs, LRU: {} PFs, OPT: {} PFs"
.format(slots, len(entries), fifo.falts, lru.falts, opt.falts))
def test_should_burst_exceptions_if_the_number_of_operations_greater_than_or_equal_to_1(
):
with raises(ValueError):
Book(Operations(Fifo()), -1)
def test_should_burst_exceptions_if_try_execute_with_number_of_operations_less_than_to_0(
):
book = Book(Operations(Fifo()), 4)
with raises(ValueError, match='Exceeded number of operations allowed'):
for x in range(0, 10):
book.add_operation('3')
def test_should_burst_exceptions_if_the_number_of_operations_less_than_or_equal_to_100000(
):
with raises(ValueError):
Book(Operations(Fifo()), 100001)
def test_empty_fifo(self):
fifo = Fifo()
self.assertEqual(1, fifo.elapse_time())
self.assertIsNone(fifo.get_next_patient())
def __init__(self, patience_rate=0):
self.corona_plus_patients = Fifo(patience_rate, "plus patients")
self.corona_minus_patients = Fifo(patience_rate, "minus patients")
from saa7113 import saa7113 from fifo import Fifo from buffer import Buffer # Use Broadcom pin numbering GPIO.setmode(GPIO.BCM) # Globals packetSize=42 # The input stream packet size. Does not include CRI and FC # Setup saa7120() saa7113() # Objects fifo=Fifo() # buffer stuff head=0 tail=0 BUFFERS = 4 buf = [0] * BUFFERS for i in range(BUFFERS): buf[i]=Buffer() countdown=BUFFERS-1 if countdown<1: countdown=1 GPIO_FLD=22 #define GPIO_FLD 3 -> Broadcom 22 GPIO_CSN=24 #define GPIO_CSN 5 -> Broadcom 24
from fifo import Fifo
from aleatory import Aleatory
from lfu import Lfu
from lru import Lru
import sys
if __name__ == "__main__":
if len(sys.argv) != 3:
print("Usage: python3 main.py algorithm cache_size")
exit(1)
with open("file.txt") as file_:
if sys.argv[1] == "fifo":
func = Fifo(int(sys.argv[-1]))
elif sys.argv[1] == "aleatory":
func = Aleatory(int(sys.argv[-1]))
elif sys.argv[1] == "lfu":
func = Lfu(int(sys.argv[-1]))
elif sys.argv[1] == "lru":
func = Lru(int(sys.argv[-1]))
for line in file_:
normalized_line = [x.strip() for x in line.split(",")]
for item in normalized_line:
func.process(item)
print(func)
