powerpc.cpp

ppc750 system design simulator using system c

	{
		integerUnit[i]->outFinished(integerFinished[i]);
		integerUnit[i]->outTag(integerTag[i]);
		
		integerUnit[i]->outResultValid(integerResultValid[i]);
		integerUnit[i]->outResultTag(integerResultTag[i]);
		integerUnit[i]->outResultData(integerResultData[i]);
		
		integerUnit[i]->outResultCRValid(integerResultCRValid[i]);
		integerUnit[i]->outResultCRTag(integerResultCRTag[i]);
		integerUnit[i]->outResultCRData(integerResultCRData[i]);
		
		integerUnit[i]->outOverflow(integerOverflow[i]);
		integerUnit[i]->outCarry(integerCarry[i]);
			
		completionUnit->inIntegerFinished[i](integerFinished[i]);
		completionUnit->inIntegerTag[i](integerTag[i]);
		completionUnit->inIntegerOverflow[i](integerOverflow[i]);
		completionUnit->inIntegerCarry[i](integerCarry[i]);
		completionUnit->inIntegerResultValid[i](integerResultValid[i]);
		completionUnit->inIntegerResultTag[i](integerResultTag[i]);
		completionUnit->inIntegerResultCRValid[i](integerResultCRValid[i]);
		completionUnit->inIntegerResultCRTag[i](integerResultCRTag[i]);
		
		dispatchUnit->inIntegerResultValid[i](integerResultValid[i]);
		dispatchUnit->inIntegerResultTag[i](integerResultTag[i]);
		dispatchUnit->inIntegerResultData[i](integerResultData[i]);
		
		dispatchUnit->inIntegerResultCRValid[i](integerResultCRValid[i]);
		dispatchUnit->inIntegerResultCRTag[i](integerResultCRTag[i]);
		dispatchUnit->inIntegerResultCRData[i](integerResultCRData[i]);
		
		registerFile->inWriteRename[IntegerWriteRenamePort + i](integerResultValid[i]);
		registerFile->inWriteRenameNumber[IntegerWriteRenamePort + i](integerResultTag[i]);
		registerFile->inWriteRenameData[IntegerWriteRenamePort + i](integerResultData[i]);
		
		conditionRegister->inWriteRenameCR[IntegerWriteRenameCRPort + i](integerResultCRValid[i]);
		conditionRegister->inWriteRenameCRNumber[IntegerWriteRenameCRPort + i](integerResultCRTag[i]);
		conditionRegister->inWriteRenameCRData[IntegerWriteRenameCRPort + i](integerResultCRData[i]);
	}
	
	/* Floating point unit results */
	for(i = 0; i < nFloatingPointUnits; i++)
	{
		floatingPointUnit[i]->outFinished(floatingPointFinished[i]);
		floatingPointUnit[i]->outTag(floatingPointTag[i]);
		
		floatingPointUnit[i]->outResultValid(floatingPointResultValid[i]);
		floatingPointUnit[i]->outResultTag(floatingPointResultTag[i]);
		floatingPointUnit[i]->outResultData(floatingPointResultData[i]);
		
		floatingPointUnit[i]->outResultCRValid(floatingPointResultCRValid[i]);
		floatingPointUnit[i]->outResultCRTag(floatingPointResultCRTag[i]);
		floatingPointUnit[i]->outResultCRData(floatingPointResultCRData[i]);
		
		completionUnit->inFloatingPointFinished[i](floatingPointFinished[i]);
		completionUnit->inFloatingPointTag[i](floatingPointTag[i]);
		completionUnit->inFloatingPointResultValid[i](floatingPointResultValid[i]);
		completionUnit->inFloatingPointResultTag[i](floatingPointResultTag[i]);
		completionUnit->inFloatingPointResultCRValid[i](floatingPointResultCRValid[i]);
		completionUnit->inFloatingPointResultCRTag[i](floatingPointResultCRTag[i]);
		
		dispatchUnit->inFloatingPointResultValid[i](floatingPointResultValid[i]);
		dispatchUnit->inFloatingPointResultTag[i](floatingPointResultTag[i]);
		dispatchUnit->inFloatingPointResultData[i](floatingPointResultData[i]);
		
		dispatchUnit->inFloatingPointResultCRValid[i](floatingPointResultCRValid[i]);
		dispatchUnit->inFloatingPointResultCRTag[i](floatingPointResultCRTag[i]);
		dispatchUnit->inFloatingPointResultCRData[i](floatingPointResultCRData[i]);
		
		registerFile->inWriteFloatingPointRename[FloatingPointWriteFloatingPointRenamePort + i](floatingPointResultValid[i]);
		registerFile->inWriteFloatingPointRenameNumber[FloatingPointWriteFloatingPointRenamePort + i](floatingPointResultTag[i]);
		registerFile->inWriteFloatingPointRenameData[FloatingPointWriteFloatingPointRenamePort + i](floatingPointResultData[i]);
		
		conditionRegister->inWriteRenameCR[FloatingPointWriteRenameCRPort + i](floatingPointResultCRValid[i]);
		conditionRegister->inWriteRenameCRNumber[FloatingPointWriteRenameCRPort + i](floatingPointResultCRTag[i]);
		conditionRegister->inWriteRenameCRData[FloatingPointWriteRenameCRPort + i](floatingPointResultCRData[i]);
	}
	
	/* load/Store unit results */
	for(i = 0; i < 2; i++)
	{
		loadStoreUnit->outFinished[i](loadStoreFinished[i]);
		loadStoreUnit->outTag[i](loadStoreTag[i]);
		completionUnit->inLoadStoreFinished[i](loadStoreFinished[i]);
		completionUnit->inLoadStoreTag[i](loadStoreTag[i]);
	}

	for(i = 0; i < 2; i++)
	{
		loadStoreUnit->outResultValid[i](loadStoreResultValid[i]);
		loadStoreUnit->outResultTag[i](loadStoreResultTag[i]);
		loadStoreUnit->outResultData[i](loadStoreResultData[i]);
		
		completionUnit->inLoadStoreResultValid[i](loadStoreResultValid[i]);
		completionUnit->inLoadStoreResultTag[i](loadStoreResultTag[i]);
		
		dispatchUnit->inLoadStoreResultValid[i](loadStoreResultValid[i]);
		dispatchUnit->inLoadStoreResultTag[i](loadStoreResultTag[i]);
		dispatchUnit->inLoadStoreResultData[i](loadStoreResultData[i]);
		
		registerFile->inWriteRename[LoadStoreWriteRenamePort + i](loadStoreResultValid[i]);
		registerFile->inWriteRenameNumber[LoadStoreWriteRenamePort + i](loadStoreResultTag[i]);
		registerFile->inWriteRenameData[LoadStoreWriteRenamePort + i](loadStoreResultData[i]);
	}
	
	loadStoreUnit->outFloatingPointResultValid(loadStoreFloatingPointResultValid);
	loadStoreUnit->outFloatingPointResultData(loadStoreFloatingPointResultData);
	
	completionUnit->inLoadStoreFloatingPointResultValid(loadStoreFloatingPointResultValid);
	
	dispatchUnit->inLoadStoreFloatingPointResultValid(loadStoreFloatingPointResultValid);
	dispatchUnit->inLoadStoreFloatingPointResultData(loadStoreFloatingPointResultData);
	
	registerFile->inWriteFloatingPointRename[LoadStoreWriteFloatingPointRenamePort](loadStoreFloatingPointResultValid);
	registerFile->inWriteFloatingPointRenameNumber[LoadStoreWriteFloatingPointRenamePort](loadStoreResultTag[0]);	
	registerFile->inWriteFloatingPointRenameData[LoadStoreWriteFloatingPointRenamePort](loadStoreFloatingPointResultData);
	
	/* Branch unit results */
	branchUnit->outResultLRValid(branchResultLRValid);
	branchUnit->outResultLRTag(branchResultLRTag);
	branchUnit->outResultLRData(branchResultLRData);
	
	branchUnit->outResultCTRValid(branchResultCTRValid);
	branchUnit->outResultCTRTag(branchResultCTRTag);
	branchUnit->outResultCTRData(branchResultCTRData);
	
	branchUnit->outMispredictedBranch(mispredictedBranch);
	branchUnit->outFinished(branchFinished);
	branchUnit->outTag(branchTag);
	branchUnit->outPC(branchPC);
	branchUnit->outUpdateBHT(updateBHT);
	branchUnit->outBHTPC(updateBHTPC);
	branchUnit->outTakenBranch(updateBHTTakenBranch);
	
	completionUnit->inBranchResultLRValid(branchResultLRValid);
	completionUnit->inBranchResultLRTag(branchResultLRTag);
	
	dispatchUnit->inBranchResultLRValid(branchResultLRValid);
	dispatchUnit->inBranchResultLRTag(branchResultLRTag);
	dispatchUnit->inBranchResultLRData(branchResultLRData);
	
	completionUnit->inBranchResultCTRValid(branchResultCTRValid);
	completionUnit->inBranchResultCTRTag(branchResultCTRTag);
	
	dispatchUnit->inBranchResultCTRValid(branchResultCTRValid);
	dispatchUnit->inBranchResultCTRTag(branchResultCTRTag);
	dispatchUnit->inBranchResultCTRData(branchResultCTRData);
	
	linkRegister->inWriteRenameLR[BranchUnitWriteRenameLRPort](branchResultLRValid);
	linkRegister->inWriteRenameLRNumber[BranchUnitWriteRenameLRPort](branchResultLRTag);
	linkRegister->inWriteRenameLRData[BranchUnitWriteRenameLRPort](branchResultLRData);
	
	countRegister->inWriteRenameCTR[BranchUnitWriteRenameCTRPort](branchResultCTRValid);
	countRegister->inWriteRenameCTRNumber[BranchUnitWriteRenameCTRPort](branchResultCTRTag);
	countRegister->inWriteRenameCTRData[BranchUnitWriteRenameCTRPort](branchResultCTRData);
	
	fetchUnit->inBranchFinished(branchFinished);
	fetchUnit->inMispredictedBranch(mispredictedBranch);
	fetchUnit->inPC(branchPC);
	
	bpu->inUpdateBHT(updateBHT);
	bpu->inUpdateBHTPC(updateBHTPC);
	bpu->inUpdateBHTTakenBranch(updateBHTTakenBranch);
	
	completionUnit->inBranchFinished(branchFinished);
	completionUnit->inBranchTag(branchTag);
	completionUnit->inMispredictedBranch(mispredictedBranch);
	completionUnit->inBranchPC(branchPC);
	
	dispatchUnit->inBranchFinished(branchFinished);
	dispatchUnit->inMispredictedBranch(mispredictedBranch);
	
	/* System register unit results */
	systemRegisterUnit->outFinished(systemRegisterFinished);
	systemRegisterUnit->outTag(systemRegisterTag);
	systemRegisterUnit->outResultValid(systemRegisterResultValid);
	systemRegisterUnit->outResultTag(systemRegisterResultTag);
	systemRegisterUnit->outResultData(systemRegisterResultData);
	systemRegisterUnit->outResultLRValid(systemRegisterResultLRValid);
	systemRegisterUnit->outResultLRTag(systemRegisterResultLRTag);
	systemRegisterUnit->outResultLRData(systemRegisterResultLRData);
	systemRegisterUnit->outResultCTRValid(systemRegisterResultCTRValid);
	systemRegisterUnit->outResultCTRTag(systemRegisterResultCTRTag);
	systemRegisterUnit->outResultCTRData(systemRegisterResultCTRData);
	systemRegisterUnit->outResultCRValid(systemRegisterResultCRValid);
	systemRegisterUnit->outResultCRTag(systemRegisterResultCRTag);
	systemRegisterUnit->outResultCRData(systemRegisterResultCRData);
	systemRegisterUnit->outCR(systemRegisterCRData);
	
	completionUnit->inSystemRegisterFinished(systemRegisterFinished);
	completionUnit->inSystemRegisterTag(systemRegisterTag);
	completionUnit->inSystemRegisterCRData(systemRegisterCRData);
	
	dispatchUnit->inSystemRegisterResultValid(systemRegisterResultValid);
	dispatchUnit->inSystemRegisterResultTag(systemRegisterResultTag);
	dispatchUnit->inSystemRegisterResultData(systemRegisterResultData);
	dispatchUnit->inSystemRegisterResultLRValid(systemRegisterResultLRValid);
	dispatchUnit->inSystemRegisterResultLRData(systemRegisterResultLRData);
	dispatchUnit->inSystemRegisterResultLRTag(systemRegisterResultLRTag);
	dispatchUnit->inSystemRegisterResultCTRValid(systemRegisterResultCTRValid);
	dispatchUnit->inSystemRegisterResultCTRTag(systemRegisterResultCTRTag);
	dispatchUnit->inSystemRegisterResultCTRData(systemRegisterResultCTRData);
	dispatchUnit->inSystemRegisterResultCRValid(systemRegisterResultCRValid);
	dispatchUnit->inSystemRegisterResultCRTag(systemRegisterResultCRTag);
	dispatchUnit->inSystemRegisterResultCRData(systemRegisterResultCRData);
	
	registerFile->inWriteRename[SystemRegisterWriteRenamePort](systemRegisterResultValid);
	registerFile->inWriteRenameNumber[SystemRegisterWriteRenamePort](systemRegisterResultTag);
	registerFile->inWriteRenameData[SystemRegisterWriteRenamePort](systemRegisterResultData);
	
	linkRegister->inWriteRenameLR[SystemRegisterWriteRenameLRPort](systemRegisterResultLRValid);	
	linkRegister->inWriteRenameLRNumber[SystemRegisterWriteRenameLRPort](systemRegisterResultLRTag);	
	linkRegister->inWriteRenameLRData[SystemRegisterWriteRenameLRPort](systemRegisterResultLRData);
	
	countRegister->inWriteRenameCTR[SystemRegisterWriteRenameCTRPort](systemRegisterResultCTRValid);	
	countRegister->inWriteRenameCTRNumber[SystemRegisterWriteRenameCTRPort](systemRegisterResultCTRTag);	
	countRegister->inWriteRenameCTRData[SystemRegisterWriteRenameCTRPort](systemRegisterResultCTRData);
	
	conditionRegister->inWriteRenameCR[SystemRegisterWriteRenameCRPort](systemRegisterResultCRValid);	
	conditionRegister->inWriteRenameCRNumber[SystemRegisterWriteRenameCRPort](systemRegisterResultCRTag);	
	conditionRegister->inWriteRenameCRData[SystemRegisterWriteRenameCRPort](systemRegisterResultCRData);
	
	completionUnit->inSystemRegisterResultValid(systemRegisterResultValid);
	completionUnit->inSystemRegisterResultTag(systemRegisterResultTag);
	completionUnit->inSystemRegisterResultLRValid(systemRegisterResultLRValid);
	completionUnit->inSystemRegisterResultLRTag(systemRegisterResultLRTag);
	completionUnit->inSystemRegisterResultCTRValid(systemRegisterResultCTRValid);
	completionUnit->inSystemRegisterResultCTRTag(systemRegisterResultCTRTag);
	completionUnit->inSystemRegisterResultCRValid(systemRegisterResultCRValid);
	completionUnit->inSystemRegisterResultCRTag(systemRegisterResultCRTag);
	
	dispatchUnit->inSystemRegisterFinished(systemRegisterFinished);	
	
	/* Write back */
	for(i = 0; i < nWriteBackPorts; i++)
	{
		completionUnit->outWriteBack[i](writeBack[i]);
		completionUnit->outWriteBackRegisterNumber[i](writeBackRegisterNumber[i]);
		completionUnit->outWriteBackRenameNumber[i](writeBackRenameNumber[i]);
		registerFile->inWriteBack[i](writeBack[i]);
		registerFile->inWriteBackRegisterNumber[i](writeBackRegisterNumber[i]);
		registerFile->inWriteBackRenameNumber[i](writeBackRenameNumber[i]);
	}

	for(i = 0; i < nWriteBackFloatingPointPorts; i++)
	{
		completionUnit->outWriteBackFloatingPoint[i](writeBackFloatingPoint[i]);
		completionUnit->outWriteBackFloatingPointRegisterNumber[i](writeBackFloatingPointRegisterNumber[i]);
		completionUnit->outWriteBackFloatingPointRenameNumber[i](writeBackFloatingPointRenameNumber[i]);
		registerFile->inWriteBackFloatingPoint[i](writeBackFloatingPoint[i]);
		registerFile->inWriteBackFloatingPointRegisterNumber[i](writeBackFloatingPointRegisterNumber[i]);
		registerFile->inWriteBackFloatingPointRenameNumber[i](writeBackFloatingPointRenameNumber[i]);
	}
	
	for(i = 0; i < nWriteBackCRPorts; i++)
	{
		completionUnit->outWriteBackCR[i](writeBackCR[i]);
		completionUnit->outWriteBackCRRenameNumber[i](writeBackCRRenameNumber[i]);
		completionUnit->outWriteBackCRFieldNumber[i](writeBackCRFieldNumber[i]);
		conditionRegister->inWriteBackCR[i](writeBackCR[i]);
		conditionRegister->inWriteBackCRRenameNumber[i](writeBackCRRenameNumber[i]);
		conditionRegister->inWriteBackCRFieldNumber[i](writeBackCRFieldNumber[i]);
	}

	for(i = 0; i < nWriteBackLRPorts; i++)
	{
		completionUnit->outWriteBackLR[i](writeBackLR[i]);
		completionUnit->outWriteBackLRRenameNumber[i](writeBackLRRenameNumber[i]);
		linkRegister->inWriteBackLR[i](writeBackLR[i]);
		linkRegister->inWriteBackLRRenameNumber[i](writeBackLRRenameNumber[i]);
	}
	
	for(i = 0; i < nWriteBackCTRPorts; i++)
	{
		completionUnit->outWriteBackCTR[i](writeBackCTR[i]);
		completionUnit->outWriteBackCTRRenameNumber[i](writeBackCTRRenameNumber[i]);
		countRegister->inWriteBackCTR[i](writeBackCTR[i]);
		countRegister->inWriteBackCTRRenameNumber[i](writeBackCTRRenameNumber[i]);
	}
	
	for(i = 0; i < nMemoryWriteBackPorts; i++)
	{
		completionUnit->outMemoryWriteBack[i](memoryWriteBack[i]);
		completionUnit->outMemoryWriteBackTag[i](memoryWriteBackTag[i]);
		loadStoreUnit->inWriteBack[i](memoryWriteBack[i]);
		loadStoreUnit->inWriteBackTag[i](memoryWriteBackTag[i]);
	}
	
	completionUnit->outWriteOverflow(writeOverflow);
	completionUnit->outOverflow(writeOverflowData);
	completionUnit->outWriteCarry(writeCarry);
	completionUnit->outCarry(writeCarryData);
	xerRegister->inWriteCarry(writeCarry);
	xerRegister->inCarry(writeCarryData);
	xerRegister->inWriteOverflow(writeOverflow);
	xerRegister->inOverflow(writeOverflowData);
	
	/* XER Register */
	xerRegister->outCarry(carry);
	xerRegister->outOverflow(overflow);
	xerRegister->outSummaryOverflow(summaryOverflow);
	
	/* Condition Register */
	conditionRegister->inSummaryOverflow(summaryOverflow);
	conditionRegister->outCR(cr);
	dispatchUnit->inCR(cr);
	systemRegisterUnit->inCR(cr);
	
	completionUnit->outWriteCR(writeCR);
	completionUnit->outCRM(crm);
	completionUnit->outCR(writeCRData);
	conditionRegister->inWriteCR(writeCR);
	conditionRegister->inCRM(crm);
	conditionRegister->inCR(writeCRData);
	
	/* Link Register */
	linkRegister->outLR(lr);
	dispatchUnit->inLR(lr);
	systemRegisterUnit->inLR(lr);
	
	/* Count Register */
	countRegister->outCTR(ctr);
	dispatchUnit->inCTR(ctr);
	systemRegisterUnit->inCTR(ctr);	
	
	/* Interlock */
	completionUnit->outClearInterlock(clearInterlock);
	dispatchUnit->inClearInterlock(clearInterlock);
	
	/* signals to ensure pipeline order */
	completionUnit->outDecode(decode);
	dispatchUnit->inDecode(decode);
	dispatchUnit->outFinish(finish);
	completionUnit->inFinish(finish);

}

void PowerPC::Reset()
{
	int i;
	
	/* Instruction cache */	
	icacheCancel.write(false);
	fetch2icacheReq.write(false);
	fetch2icacheAddr.write(0);
	fetch2icacheSize.write(false);
	icache2fetchAck.write(false);
	icache2fetchHit.write(false);
	
	/* Bus interface */
	icache2biuReq.write(false);
	icache2biuAddr.write(0);
	biu2icacheAck.write(false);
	
	/* Branch Prediction */
	readBHTPC.write(0);
	readBTICPC.write(0);
	
	readBHTTakenBranch.write(false);
		
	readBTICInstructionsCount.write(0);
	readBTICHit.write(false);
	
	for(i = 0; i < nInstructionsPerBTICEntry; i++)
		readBTICInstructions[i].write(0);
	
	updateBTIC.write(false);
	updateBTICPC.write(0);
	updateBTICInstructionsCount.write(0);
	
	for(i = 0; i < nInstructionsPerBTICEntry; i++)
		updateBTICInstructions[i].write(0);

	/* Instructions into instructio queue */
	instructionsInQueue.write(0);
	branchsInQueue.write(0);
	dispatchedInstructions.write(0);
	dispatchedBranchs.write(0);
	
	/* Register File */
	for(i = 0; i < nReadRegisterPorts; i++)
	{
		readRegisterNumber[i].write(0);
		readRegisterData[i].write(0);
	}
	
	for(i = 0; i < nReadFloatingPointRegisterPorts; i++)
	{
		readFloatingPointRegisterNumber[i].write(0);
		readFloatingPointRegisterData[i].write(0);
	}
	
	for(i = 0; i < nReadRenamePorts; i++)
	{
		readRenameNumber[i].write(0);
		readRenameData[i].write(0);
	}
	
	for(i = 0; i < nReadFloatingPointRenamePorts; i++)
	{
		readFloatingPointRenameNumber[i].write(0);
		readFloatingPointRenameData[i].write(0);
	}
	/* Condition Register */
	for(i = 0; i < nReadRenameCRPorts; i++)
	{