add bpu_top/

tests/bpu_top/config.py

@@ -0,0 +1,6 @@
+import os
+ROOT_PATH = os.path.dirname(os.path.abspath(__file__))+"/../../"
+TESTS_PATH = ROOT_PATH + "tests/"
+DUT_PATH = ROOT_PATH + "out/picker_out_BPUTop/"
+#os.sys.path.append(DUT_PATH)
+

tests/bpu_top/test_bpu_reset_true.py

@@ -0,0 +1,50 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+"""
+#######Usr function #######
+"""
+
+async def bpu_reset_true():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	await bpu.cfg_default(dut)
+
+	await dut.AStep(1)
+	bpu.reset_bpu(dut,1)
+	##TEST TASK Here
+	#set the io_reset_vector[] 
+	await dut.AStep(2)
+
+	#Finish
+	await task
+	dut.Finish()
+	print("test_bpu_sanity() exec over!!!")
+
+
+def test_bpu_sanity():
+	asyncio.run(bpu_reset_true())
+
+if __name__ == "__main__":
+	asyncio.run(bpu_reset_true())
+	

tests/bpu_top/test_bpu_reset_vector.py

@@ -0,0 +1,56 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+"""
+#######Usr function #######
+"""
+async def bpu_reset_vector_test(dut: DUTPredictor):
+	changed_value = 0x100
+	dut.io_reset_vector.value = bpu.set_pin_bits(dut.io_reset_vector.value, 35, 0, changed_value)
+	await dut.AStep(1)
+	bpu.reset_bpu(dut,1)
+	await dut.AStep(10)
+	bpu.reset_bpu(dut,0)
+	await dut.AStep(10)
+
+
+async def main():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	await bpu.cfg_default(dut)
+
+	#TEST Here
+	await bpu_reset_vector_test(dut)
+
+	#Finish
+	await task
+	dut.Finish()
+	print("test_bpu_sanity() exec over!!!")
+
+def test_bpu_reset_vector():
+	asyncio.run(main())
+
+if __name__ == "__main__":
+	asyncio.run(main())
+
+	

tests/bpu_top/test_bpu_sanity.py

@@ -0,0 +1,100 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+"""
+#######Usr function #######
+"""
+
+async def cfg_default(dut: DUTPredictor):
+	set_bpu_ctrl(dut,1)
+	reset_bpu(dut,1)
+	dut.io_reset_vector.value = 0x1000
+	dut.io_bpu_to_ftq_resp_ready.value = 1
+	await dut.AStep(2)
+	reset_bpu(dut,0)
+	await dut.AStep(2050)
+
+def reset_bpu(dut: DUTPredictor,data: int):
+	dut.reset.value = data
+
+def set_bpu_ctrl(dut: DUTPredictor,data: int) -> None:
+	dut.io_ctrl_btb_enable.value = data
+	dut.io_ctrl_ubtb_enable.value= data
+	dut.io_ctrl_ras_enable.value = data
+	dut.io_ctrl_tage_enable.value= data
+	dut.io_ctrl_sc_enable.value	 = data
+
+async def set_bpu_ftq(dut: DUTPredictor) -> None:
+	dut.io_bpu_to_ftq_resp_ready.value = 0
+	await dut.AStep(2)
+	dut.io_bpu_to_ftq_resp_ready.value = 1
+
+def set_pin_bits(pin: int, high: int, low: int, value:int) -> int:
+	"""
+	Function: set pin's bits from low to high as value
+
+	Args:
+		-pin:dut.pin.value
+		-high:
+		-low:can from zero start
+		-value:the set value
+	
+	Returns: the calculated value 
+	"""
+	low_high_mask = ((1 << (high - low + 1)) -1) << low
+	cleard_pin = pin & ~low_high_mask
+	shifted_value = value << low
+	pin = cleard_pin | shifted_value
+	return pin
+	
+
+#def set_bits(pin,high: int,low: int ,value: int):
+
+async def bpu_sanity_test():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+
+	task = asyncio.create_task(dut.RunStep(20))	#create a async task
+	dut.reset.value = 0
+	await dut.AStep(2)
+	dut.reset.value = 1
+
+	await dut.AStep(1)
+	set_bpu_ctrl(dut,1)
+	await dut.AStep(2)
+	set_bpu_ctrl(dut,0)
+	
+#	dut.io_reset_vector.value = set_pin_bits(dut.io_reset_vector.value, 2, 1, 3)
+
+	#Finish
+	await task
+	dut.Finish()
+	print("test_bpu_sanity() exec over!!!")
+
+
+def tet_bpu_sanity(request):
+	asyncio.run(bpu_sanity_test())
+	set_line_coverage(request, "report/BPUTop_coverage.dat")
+
+if __name__ == "__main__":
+	asyncio.run(bpu_sanity_test())
+	

tests/bpu_top/test_bpu_sub_uftb_enable.py

@@ -0,0 +1,113 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+"""
+#######Usr function #######
+"""
+
+def cfg_ftq_entry_value_for_uftb(dut: DUTPredictor):
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_valid.value = 0b1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_offset.value= 0xA
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_lower.value	= 0xABC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_tarStat.value = 0x3
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_sharing = 0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_valid.value	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_offset.value 	= 0xB
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_lower.value 	= 0xCCCCC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_tarStat.value	= 0x2
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_sharing.value	= 0x0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_pftAddr.value 	= 0xC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_carry.value 	= 0x0
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_0.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_1.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_0.value = 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_1.value = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isCall= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isRet = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isJalr= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_last_may_be_rvi_call = 0x1
+
+async def bpu_sub_uftb_enable_test(dut: DUTPredictor):
+	await dut.AStep(2050)
+	dut.reset.value = 1
+	await dut.AStep(2)
+	dut.reset.value = 0
+	for i in range(32):
+		dut.io_ftq_to_bpu_update_valid.value = 1
+		dut.io_ftq_to_bpu_update_bits_pc.value = 0x1000 + 0x20 * i
+		cfg_ftq_entry_value_for_uftb(dut)
+		await dut.AStep(1)
+
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	await dut.AStep(1)
+	await dut.AStep(2050)
+#	await dut.AStep(2100)
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1200
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+	#The second the update PC
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1080
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+	#The third the update PC
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1180
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+
+#	dut.io_ctrl_ubtb_enable.value = 0
+
+async def main():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+#	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	task = asyncio.create_task(dut.RunStep(5000))	#create a async task
+	task_cfg_default = asyncio.create_task(bpu.cfg_default(dut))
+	task_test_bpu_sub_uftb_enable = asyncio.create_task(bpu_sub_uftb_enable_test(dut))
+
+
+	#TEST Here
+	await task_test_bpu_sub_uftb_enable
+
+	#Finish
+	await task_cfg_default
+	await task
+	dut.Finish()
+	print("test_bpu_sanity() exec over!!!")
+
+
+def test_bpu_sub_uftb_enable():
+	asyncio.run(main())
+
+if __name__ == "__main__":
+	asyncio.run(main())
+	

tests/bpu_top/test_bpu_sub_uftb_enable_disable.py

@@ -0,0 +1,121 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+
+"""
+#######Usr function #######
+"""
+
+def cfg_ftq_entry_value_for_uftb(dut: DUTPredictor):
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_valid.value = 0b1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_offset.value= 0xA
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_lower.value	= 0xABC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_tarStat.value = 0x3
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_sharing = 0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_valid.value	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_offset.value 	= 0xB
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_lower.value 	= 0xCCCCC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_tarStat.value	= 0x2
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_sharing.value	= 0x0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_pftAddr.value 	= 0xC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_carry.value 	= 0x0
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_0.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_1.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_0.value = 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_1.value = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isCall= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isRet = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isJalr= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_last_may_be_rvi_call = 0x1
+
+async def bpu_sub_uftb_enable_disable_test(dut: DUTPredictor):
+	await dut.AStep(2050)
+	dut.reset.value = 1
+	await dut.AStep(2)
+	dut.reset.value = 0
+	for i in range(32):
+		dut.io_ftq_to_bpu_update_valid.value = 1
+		dut.io_ftq_to_bpu_update_bits_pc.value = 0x1000 + 0x20 * i
+		cfg_ftq_entry_value_for_uftb(dut)
+		await dut.AStep(1)
+
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	await dut.AStep(1)
+	await dut.AStep(2050)
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1200
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+	#The second the update PC
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1080
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+
+	##uftb_enable reset
+	dut.io_ctrl_ubtb_enable.value = 0
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1200
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+	#The second the update PC
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1080
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+#	dut.io_ctrl_ubtb_enable.value = 0
+
+async def main():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+#	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	task = asyncio.create_task(dut.RunStep(5000))	#create a async task
+	task_cfg_default = asyncio.create_task(bpu.cfg_default(dut))
+	task_test_bpu_sub_uftb_enable_disable = asyncio.create_task(bpu_sub_uftb_enable_disable_test(dut))
+
+
+	#TEST Here
+	await task_test_bpu_sub_uftb_enable_disable
+
+	#Finish
+	await task_cfg_default
+	await task
+	dut.Finish()
+	print("test_bpu_sanity() exec over!!!")
+
+def	test_bpu_sub_uftb_enable_disable():
+	asyncio.run(main())
+
+if __name__ == "__main__":
+	asyncio.run(main())
+	

tests/bpu_top/test_bpu_sub_uftb_entry_way_resp_hit.py

@@ -0,0 +1,99 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+
+"""
+#######Usr function #######
+"""
+
+def cfg_ftq_entry_value_for_uftb(dut: DUTPredictor):
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_valid.value = 0b1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_offset.value= 0xA
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_lower.value	= 0xABC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_tarStat.value = 0x3
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_sharing = 0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_valid.value	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_offset.value 	= 0xB
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_lower.value 	= 0xCCCCC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_tarStat.value	= 0x2
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_sharing.value	= 0x0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_pftAddr.value 	= 0xC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_carry.value 	= 0x0
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_0.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_1.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_0.value = 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_1.value = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isCall= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isRet = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isJalr= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_last_may_be_rvi_call = 0x1
+
+async def bpu_sub_uftb_entry_way_resp_hit_test(dut: DUTPredictor):
+	await dut.AStep(2050)
+	dut.reset.value = 1
+	await dut.AStep(2)
+	dut.reset.value = 0
+	for i in range(32):
+		dut.io_ftq_to_bpu_update_valid.value = 1
+		dut.io_ftq_to_bpu_update_bits_pc.value = 0x1000 + 0x20 * i
+		cfg_ftq_entry_value_for_uftb(dut)
+		await dut.AStep(1)
+
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	await dut.AStep(1)
+	await dut.AStep(2050)
+#	await dut.AStep(2100)
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1200
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+
+#	dut.io_ctrl_ubtb_enable.value = 0
+
+async def main():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+#	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	task = asyncio.create_task(dut.RunStep(5000))	#create a async task
+	task_cfg_default = asyncio.create_task(bpu.cfg_default(dut))
+	task_test_bpu_sub_uftb_entry_way_resp_hit = asyncio.create_task(bpu_sub_uftb_entry_way_resp_hit_test(dut))
+
+
+	#TEST Here
+	await task_test_bpu_sub_uftb_entry_way_resp_hit
+
+	#Finish
+	await task_cfg_default
+	await task
+	dut.Finish()
+	print("test_bpu_sanity() exec over!!!")
+
+def test_bpu_sub_uftb_entry_way_resp_hit():
+	asyncio.run(main())
+
+if __name__ == "__main__":
+	asyncio.run(main())
+	

tests/bpu_top/test_bpu_sub_uftb_entry_way_update_hit.py

@@ -0,0 +1,93 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+"""
+#######Usr function #######
+"""
+
+def cfg_ftq_entry_value_for_uftb(dut: DUTPredictor):
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_valid.value = 0b1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_offset.value= 0xA
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_lower.value	= 0xABC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_tarStat.value = 0x3
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_sharing = 0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_valid.value	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_offset.value 	= 0xB
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_lower.value 	= 0xCCCCC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_tarStat.value	= 0x2
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_sharing.value	= 0x0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_pftAddr.value 	= 0xC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_carry.value 	= 0x0
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_0.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_1.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_0.value = 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_1.value = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isCall= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isRet = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isJalr= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_last_may_be_rvi_call = 0x1
+
+async def bpu_sub_uftb_entry_way_update_hit_test(dut: DUTPredictor):
+	await dut.AStep(2050)
+	for i in range(32):
+		dut.io_ftq_to_bpu_update_valid.value = 1
+		dut.io_ftq_to_bpu_update_bits_pc.value = 0x1000 + 0x20 * i
+		cfg_ftq_entry_value_for_uftb(dut)
+		await dut.AStep(1)
+
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	await dut.AStep(100)
+	for i in range(32):
+		dut.io_ftq_to_bpu_update_valid.value = 1
+		dut.io_ftq_to_bpu_update_bits_pc.value = 0x1000 + 0x20 * i
+		cfg_ftq_entry_value_for_uftb(dut)
+		await dut.AStep(1)
+
+#	dut.io_ctrl_ubtb_enable.value = 0
+
+async def main():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+#	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	task = asyncio.create_task(dut.RunStep(5000))	#create a async task
+	task_cfg_default = asyncio.create_task(bpu.cfg_default(dut))
+	task_test_bpu_sub_uftb_entry_way_update_hit = asyncio.create_task(bpu_sub_uftb_entry_way_update_hit_test(dut))
+
+
+	#TEST Here
+	await task_test_bpu_sub_uftb_entry_way_update_hit
+
+	#Finish
+	await task_cfg_default
+	await task
+	dut.Finish()
+
+	print("test_bpu_sanity() exec over!!!")
+
+def test_bpu_sub_uftb_entry_way_update_hit():
+	asyncio.run(main())
+
+if __name__ == "__main__":
+	asyncio.run(main())
+	

tests/bpu_top/test_bpu_sub_uftb_ready.py

@@ -0,0 +1,87 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+"""
+#######Usr function #######
+"""
+
+def cfg_ftq_entry_value_for_uftb(dut: DUTPredictor):
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_valid.value = 0b1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_offset.value= 0xA
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_lower.value	= 0xABC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_tarStat.value = 0x3
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_sharing = 0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_valid.value	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_offset.value 	= 0xB
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_lower.value 	= 0xCCCCC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_tarStat.value	= 0x2
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_sharing.value	= 0x0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_pftAddr.value 	= 0xC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_carry.value 	= 0x0
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_0.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_1.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_0.value = 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_1.value = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isCall= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isRet = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isJalr= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_last_may_be_rvi_call = 0x1
+
+async def bpu_sub_uftb_ready_test(dut: DUTPredictor):
+	await dut.AStep(2050)
+
+	dut.io_bpu_to_ftq_resp_ready.value = 0
+	await dut.AStep(100)
+	dut.io_bpu_to_ftq_resp_ready.value = 1
+	await dut.AStep(100)
+	dut.io_bpu_to_ftq_resp_ready.value = 0
+	await dut.AStep(100)
+	
+
+#	dut.io_ctrl_ubtb_enable.value = 0
+
+async def main():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+#	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	task = asyncio.create_task(dut.RunStep(5000))	#create a async task
+	task_cfg_default = asyncio.create_task(bpu.cfg_default(dut))
+	task_test_bpu_sub_uftb_ready = asyncio.create_task(bpu_sub_uftb_ready_test(dut))
+
+
+	#TEST Here
+	await task_test_bpu_sub_uftb_ready
+
+	#Finish
+	await task_cfg_default
+	await task
+	dut.Finish()
+	print("mian() exec over!!!")
+
+def test_bpu_sub_uftb_ready():
+	asyncio.run(main())
+
+if __name__ == "__main__":
+	asyncio.run(main())
+	

tests/bpu_top/test_bpu_sub_uftb_reset.py

@@ -0,0 +1,99 @@
+from config import *
+
+import os
+os.sys.path.append(TESTS_PATH)
+os.sys.path.append(DUT_PATH)
+
+from UT_Predictor import *
+import random
+
+import mlvp
+import logging
+
+import mlvp.funcov as fc
+from mlvp.reporter import *
+
+import asyncio
+
+import test_bpu_sanity as bpu
+
+"""
+#######Usr function #######
+"""
+
+def cfg_ftq_entry_value_for_uftb(dut: DUTPredictor):
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_valid.value = 0b1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_offset.value= 0xA
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_lower.value	= 0xABC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_tarStat.value = 0x3
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_brSlots_0_sharing = 0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_valid.value	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_offset.value 	= 0xB
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_lower.value 	= 0xCCCCC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_tarStat.value	= 0x2
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_tailSlot_sharing.value	= 0x0
+
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_pftAddr.value 	= 0xC
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_carry.value 	= 0x0
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_0.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_ftb_entry_always_taken_1.value 	= 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_0.value = 0x1
+	dut.io_ftq_to_bpu_update_bits_br_taken_mask_1.value = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isCall= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isRet = 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_isJalr= 0x1
+#	dut.io_ftq_to_bpu_update_bits_ftb_entry_last_may_be_rvi_call = 0x1
+
+async def bpu_sub_uftb_reset_test(dut: DUTPredictor):
+	await dut.AStep(2050)
+	dut.reset.value = 1
+	await dut.AStep(4)
+	dut.reset.value = 0
+	for i in range(32):
+		dut.io_ftq_to_bpu_update_valid.value = 1
+		dut.io_ftq_to_bpu_update_bits_pc.value = 0x1000 + 0x20 * i
+		cfg_ftq_entry_value_for_uftb(dut)
+		await dut.AStep(1)
+
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	await dut.AStep(1)
+	await dut.AStep(2050)
+	dut.reset.value = 1
+#	await dut.AStep(2100)
+	dut.io_ftq_to_bpu_update_valid.value = 1
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x1200
+	await dut.AStep(1)
+	dut.io_ftq_to_bpu_update_valid.value = 0
+	dut.io_ftq_to_bpu_update_bits_pc.value = 0x0000
+	await dut.AStep(1)
+
+#	dut.io_ctrl_ubtb_enable.value = 0
+
+async def main():
+	dut: DUTPredictor = DUTPredictor(
+		waveform_filename="report/BPUTop.fst", coverage_filename="report/BPUTop_coverage.dat")
+#	print(TEST_PATH)
+	print("Init DUT is OK!!!")
+	dut.InitClock("clock")
+#	task = asyncio.create_task(dut.RunStep(2100))	#create a async task
+	task = asyncio.create_task(dut.RunStep(5000))	#create a async task
+	task_cfg_default = asyncio.create_task(bpu.cfg_default(dut))
+	task_bpu_sub_uftb_reset_test = asyncio.create_task(bpu_sub_uftb_reset_test(dut))
+
+
+	#TEST Here
+	await task_bpu_sub_uftb_reset_test
+
+	#Finish
+	await task_cfg_default
+	await task
+	dut.Finish()
+	print("mian() exec over!!!")
+
+def test_bpu_sub_uftb_reset():
+	asyncio.run(main())
+
+if __name__ == "__main__":
+	asyncio.run(main())
+