Справица:DiagramGenerator/actions.js - Историја измена

KockaAdmiralac: Evaluacija izraza poput 0 + 0

2023-02-09T14:44:12Z

Evaluacija izraza poput 0 + 0

@@ Ред 146: / Ред 146: @@
              buses[busName] = hadValue ? 'CONFLICT' : regName;
          });
+     }
@@ Ред 152: / Ред 185: @@
          var A = buses.iBus3 === 'HiZ' ? '0' : buses.iBus3;
          var B = buses.iBus2 === 'HiZ' ? '0' : buses.iBus2;
          switch (signal) {
              case 'add':
@@ Ред 231: / Ред 267: @@
                  if (buses.iBus1 === 'HiZ' || buses.iBus3 === 'HiZ') {
                      diffFound |= writeBus(buses, 'iBus2', '0');
                  } else {
                      diffFound |= writeBus(buses, 'iBus2', buses.iBus1 + ' + ' + buses.iBus3);

KockaAdmiralac: Prosleđivanje grešaka i korišćenje sistemskih poruka

2023-02-04T20:33:20Z

Prosleđivanje grešaka i korišćenje sistemskih poruka

← Старија измена		Верзија на датум 4. фебруар 2023. у 22:33
Ред 40:		Ред 40:
	cl: [],		cl: [],
	dec: [],		dec: [],
			errors: [],
	inc: [],		inc: [],
	ld: [],		ld: [],
Ред 52:		Ред 53:
	if (ALU_SIGNALS.includes(signal)) {		if (ALU_SIGNALS.includes(signal)) {
	if (classification.alu) {		if (classification.alu) {
	~~console~~.~~warn~~('~~Two ALU signals active at the same time:~~ ' + signal ~~+ ' and ' +~~ classification.alu);		classification.errors.push(mw.libs.diagramGenerator.msg('error-2-alu', signal, classification.alu));
	} else {		} else {
	classification.alu = signal;		classification.alu = signal;
Ред 103:		Ред 104:
	var wr = clsSignals.map.wrCPU;		var wr = clsSignals.map.wrCPU;
	if (rd && wr) {		if (rd && wr) {
	~~return~~ '~~RD_WR_ERROR~~';		clsSignals.errors.push(mw.libs.diagramGenerator.msg('error-rd-wr'));
			return;
	}		}
	if (rd) {		if (rd) {
	if (clsSignals.map.eMDR) {		if (clsSignals.map.eMDR) {
	~~return~~ '~~DBUS_CONFLICT~~';		clsSignals.errors.push(mw.libs.diagramGenerator.msg('error-dbus-conflict'));
			return;
	}		}
	if (!clsSignals.map.eMAR) {		if (!clsSignals.map.eMAR) {
	~~return~~ '~~RD_NO_MAR_ERROR~~';		clsSignals.errors.push(mw.libs.diagramGenerator.msg('error-rd-no-mar'));
			return;
	}		}
	buses.mdrI = 'MEM[MAR]';		buses.mdrI = 'MEM[MAR]';
Ред 118:		Ред 122:
	} else if (wr) {		} else if (wr) {
	if (!clsSignals.map.eMDR) {		if (!clsSignals.map.eMDR) {
	~~return~~ '~~MEM[ABUS] <= HiZ~~';		clsSignals.errors.push(mw.libs.diagramGenerator.msg('error-wr-no-mdr'));
			return;
	}		}
	if (!clsSignals.map.eMAR) {		if (!clsSignals.map.eMAR) {
	~~return~~ '~~MEM[HiZ] <= MDR~~';		clsSignals.errors.push(mw.libs.diagramGenerator.msg('error-wr-no-mar'));
			return;
	}		}
	buses.mdrI = 'MDR';		buses.mdrI = 'MDR';
Ред 134:		Ред 140:
	var busName = 'iBus' + busNum;		var busName = 'iBus' + busNum;
	var hadValue = buses[busName] !== 'HiZ' && buses[busName] !== regName;		var hadValue = buses[busName] !== 'HiZ' && buses[busName] !== regName;
			if (hadValue) {
			var errMsg = mw.libs.diagramGenerator.msg('error-conflict', busName, buses[busName], regName);
			clsSignals.errors.push(errMsg);
			}
	buses[busName] = hadValue ? 'CONFLICT' : regName;		buses[busName] = hadValue ? 'CONFLICT' : regName;
	});		});
Ред 234:		Ред 244:
	}		}
	if (diffFound) {		if (diffFound) {
	~~console~~.~~warn~~('~~Failed to calculate dependent bus signal values:~~'~~, clsSignals~~);		clsSignals.errors.push(mw.libs.diagramGenerator.msg('error-infinite-loop'));
	}		}
	if (clsSignals.map.mxMDR) {		if (clsSignals.map.mxMDR) {
Ред 291:		Ред 301:
	// All signals are calculated, decide which actions these signals result in		// All signals are calculated, decide which actions these signals result in
	actions = actions.concat(executeActions(clsSignals, buses));		actions = actions.concat(executeActions(clsSignals, buses));
	return actions;		// All done, check and report errors
			if (actions.some(function(action) {
			return action.includes('HiZ');
			})) {
			clsSignals.errors.push();
			}
			return {
			errors: clsSignals.errors,
			result: actions
			};
	}		}

KockaAdmiralac: Smislenije rukovanje HiZ vrednostima

2023-02-04T16:02:34Z

Smislenije rukovanje HiZ vrednostima

← Старија измена		Верзија на датум 4. фебруар 2023. у 18:02
Ред 139:		Ред 139:

	function getAluOutput(buses, signal) {		function getAluOutput(buses, signal) {
			// ALU inputs on HiZ are treated as 0.
			var A = buses.iBus3 === 'HiZ' ? '0' : buses.iBus3;
			var B = buses.iBus2 === 'HiZ' ? '0' : buses.iBus2;
	switch (signal) {		switch (signal) {
	case 'add':		case 'add':
	return ~~buses.iBus3~~ + ' + ' + ~~buses.iBus2~~;		return A + ' + ' + B;
	case 'sub':		case 'sub':
	return ~~buses.iBus3~~ + ' - ' + ~~buses.iBus2~~;		return A + ' - ' + B;
	case 'inc':		case 'inc':
	return ~~buses.iBus3~~ + ' + 1';		return A + ' + 1';
	case 'dec':		case 'dec':
	return ~~buses.iBus3~~ + ' - 1';		return A + ' - 1';
	case 'and':		case 'and':
	return ~~buses.iBus3~~ + ' & ' + ~~buses.iBus2~~;		return A + ' & ' + B;
	case 'or':		case 'or':
	return ~~buses.iBus3~~ + ' \| ' + ~~buses.iBus2~~;		return A + ' \| ' + B;
	case 'xor':		case 'xor':
	return ~~buses.iBus3~~ + ' ^ ' + ~~buses.iBus2~~;		return A + ' ^ ' + B;
	case 'not':		case 'not':
	return '~' + ~~buses.iBus3~~;		return '~' + A;
	case 'shr':		case 'shr':
	return ~~buses.iBus3~~ + ' >> ' + ~~buses.iBus2~~;		return A + ' >> ' + B;
	case 'shl':		case 'shl':
	return ~~buses.iBus3~~ + ' << ' + ~~buses.iBus2~~;		return A + ' << ' + B;
	default:		default:
	return '0';		return '0';
Ред 215:		Ред 218:
	}		}
	if (clsSignals.map.ADDout2) {		if (clsSignals.map.ADDout2) {
	diffFound \|= writeBus(buses, 'iBus2', buses.iBus1 + ' + ' + buses.iBus3);		// If any adder input is HiZ, the output is zero.
			if (buses.iBus1 === 'HiZ' \|\| buses.iBus3 === 'HiZ') {
			diffFound \|= writeBus(buses, 'iBus2', '0');
			} else {
			diffFound \|= writeBus(buses, 'iBus2', buses.iBus1 + ' + ' + buses.iBus3);
			}
	}		}
	diffFound \|= clsSignals.bridge.map(function(bridge) {		diffFound \|= clsSignals.bridge.map(function(bridge) {
	return writeBus(buses, 'iBus' + bridge[1], ~~buses[~~'~~iBus~~' ~~+ bridge[0]]~~);		var busValue = buses['iBus' + bridge[0]];
			// Tri-state buffers output -1 if their input is HiZ.
			return writeBus(buses, 'iBus' + bridge[1], busValue === 'HiZ' ? '-1' : busValue);
	}).reduce(function(a, b) {		}).reduce(function(a, b) {
	return a + b;		return a + b;
Ред 227:		Ред 237:
	}		}
	if (clsSignals.map.mxMDR) {		if (clsSignals.map.mxMDR) {
	buses.mdrI = buses.iBus3;		// Multiplexer outputs zero if the selected input is HiZ.
			buses.mdrI = buses.iBus3 === 'HiZ' ? '0' : buses.iBus3;
	}		}
	}		}

KockaAdmiralac: Modul za određivanje makro-akcija na osnovu signala

2023-02-04T02:57:04Z

Modul za određivanje makro-akcija na osnovu signala

Нова страница

/* eslint {"max-statements": ["error", 50]} */
(function() {
'use strict';
var ALU_SIGNALS = ['add', 'sub', 'inc', 'dec', 'and', 'or', 'xor', 'not', 'shr', 'shl'];
var MAX_ITER_DEPENDENT_SIGNALS = 10;

function translateRegName(regName) {
var regPrefix = regName.slice(0, -1);
var regSuffix = regName.slice(-1);
if (regSuffix === 'H') {
return regPrefix + '15..8';
}
if (regName.endsWith('L')) {
return regPrefix + '7..0';
}
if (regName.endsWith('0')) {
return regPrefix + '31..24';
}
if (regName.endsWith('1')) {
return regPrefix + '23..16';
}
if (regName.endsWith('2')) {
return regPrefix + '15..8';
}
if (regName.endsWith('3')) {
return regPrefix + '7..0';
}
if (regName === 'GPR') {
return 'GPR[AR]';
}
if (regName === 'IVTDSP') {
return 'BR << 1';
}
return regName;
}

function classifySignals(signals) {
var classification = {
bridge: [],
cl: [],
dec: [],
inc: [],
ld: [],
ldPSW: [],
map: {},
out: [],
st: []
};
signals.forEach(function(signal) {
classification.map[signal] = true;
var regName;
if (ALU_SIGNALS.includes(signal)) {
if (classification.alu) {
console.warn('Two ALU signals active at the same time: ' + signal + ' and ' + classification.alu);
} else {
classification.alu = signal;
}
}
if (signal.includes('out')) {
var splitOutSignal = signal.split('out');
regName = translateRegName(splitOutSignal[0]);
if (regName === 'ALU' || regName === 'ADD') {
// Dependent output signals
return;
}
var busNum = Number(splitOutSignal[1]);
if (!isNaN(busNum)) {
classification.out.push([regName, busNum]);
}
}
if (signal.startsWith('ld') || signal === 'wrGPR') {
regName = signal.substring(2);
if (regName.length === 1) {
classification.ldPSW.push(regName);
} else {
classification.ld.push(translateRegName(regName));
}
}
if (signal.startsWith('MOST')) {
var bridgeData = signal.substring(4).split('_');
var srcBridge = Number(bridgeData[0]);
var dstBridge = Number(bridgeData[1]);
classification.bridge.push([srcBridge, dstBridge]);
}
if (signal.startsWith('inc') && signal !== 'inc') {
classification.inc.push(translateRegName(signal.substring(3)));
}
if (signal.startsWith('dec') && signal !== 'dec') {
classification.dec.push(translateRegName(signal.substring(3)));
}
if (signal.startsWith('st')) {
classification.st.push(translateRegName(signal.substring(2)));
}
if (signal.startsWith('cl')) {
classification.cl.push(translateRegName(signal.substring(2)));
}
});
return classification;
}

function calculateMemory(clsSignals, buses) {
var rd = clsSignals.map.rdCPU;
var wr = clsSignals.map.wrCPU;
if (rd && wr) {
return 'RD_WR_ERROR';
}
if (rd) {
if (clsSignals.map.eMDR) {
return 'DBUS_CONFLICT';
}
if (!clsSignals.map.eMAR) {
return 'RD_NO_MAR_ERROR';
}
buses.mdrI = 'MEM[MAR]';
if (!clsSignals.ld.includes('MDR')) {
clsSignals.ld.push('MDR');
}
} else if (wr) {
if (!clsSignals.map.eMDR) {
return 'MEM[ABUS] <= HiZ';
}
if (!clsSignals.map.eMAR) {
return 'MEM[HiZ] <= MDR';
}
buses.mdrI = 'MDR';
return 'MEM[MAR] <= MDR';
}
}

function calculateIndependentBusOutput(clsSignals, buses) {
clsSignals.out.forEach(function(outData) {
var regName = outData[0];
var busNum = outData[1];
var busName = 'iBus' + busNum;
var hadValue = buses[busName] !== 'HiZ' && buses[busName] !== regName;
buses[busName] = hadValue ? 'CONFLICT' : regName;
});
}

function getAluOutput(buses, signal) {
switch (signal) {
case 'add':
return buses.iBus3 + ' + ' + buses.iBus2;
case 'sub':
return buses.iBus3 + ' - ' + buses.iBus2;
case 'inc':
return buses.iBus3 + ' + 1';
case 'dec':
return buses.iBus3 + ' - 1';
case 'and':
return buses.iBus3 + ' & ' + buses.iBus2;
case 'or':
return buses.iBus3 + ' | ' + buses.iBus2;
case 'xor':
return buses.iBus3 + ' ^ ' + buses.iBus2;
case 'not':
return '~' + buses.iBus3;
case 'shr':
return buses.iBus3 + ' >> ' + buses.iBus2;
case 'shl':
return buses.iBus3 + ' << ' + buses.iBus2;
default:
return '0';
}
}

function writeBus(buses, busName, value) {
if (buses[busName] === value) {
return false;
}
buses[busName] = value;
return true;
}

function getValueToLoad(buses, regName) {
switch (regName) {
case 'MDR':
return buses.mdrI;
case 'DW15..8':
case 'DW7..0':
case 'GPRAR':
case 'IR31..24':
case 'IR23..16':
case 'IR15..8':
case 'IR7..0':
case 'AB':
case 'BB':
case 'PSW15..8':
case 'PSW7..0':
return buses.iBus1;
case 'MAR':
case 'CW':
case 'PC':
case 'AW':
case 'BW':
return buses.iBus2;
case 'GPR[AR]':
case 'SP':
case 'IMR':
case 'BR':
case 'IVTP':
return buses.iBus3;
default:
return 'HiZ';
}
}

function calculateDependentBusOutput(clsSignals, buses) {
var diffFound = 1;
for (var iter = 0; iter < MAX_ITER_DEPENDENT_SIGNALS && diffFound; ++iter) {
diffFound = 0;
diffFound |= writeBus(buses, 'aluOut', getAluOutput(buses, clsSignals.alu));
if (clsSignals.map.ALUout1) {
diffFound |= writeBus(buses, 'iBus1', buses.aluOut);
}
if (clsSignals.map.ADDout2) {
diffFound |= writeBus(buses, 'iBus2', buses.iBus1 + ' + ' + buses.iBus3);
}
diffFound |= clsSignals.bridge.map(function(bridge) {
return writeBus(buses, 'iBus' + bridge[1], buses['iBus' + bridge[0]]);
}).reduce(function(a, b) {
return a + b;
}, 0);
}
if (diffFound) {
console.warn('Failed to calculate dependent bus signal values:', clsSignals);
}
if (clsSignals.map.mxMDR) {
buses.mdrI = buses.iBus3;
}
}

function executeActions(clsSignals, buses) {
var ldActions = clsSignals.ld.map(function(regName) {
return regName + ' <= ' + getValueToLoad(buses, regName);
});
var ldPSWActions = clsSignals.ldPSW.map(function(bitName) {
return 'PSW' + bitName + ' <= ' + bitName;
});
var incActions = clsSignals.inc.map(function(regName) {
return regName + '++';
});
var decActions = clsSignals.dec.map(function(regName) {
return regName + '--';
});
var stActions = clsSignals.st.map(function(regName) {
return regName + ' <= 1';
});
var clActions = clsSignals.cl.map(function(regName) {
return regName + ' <= 0';
});
return ldActions
.concat(ldPSWActions)
.concat(incActions)
.concat(decActions)
.concat(stActions)
.concat(clActions);
}

function main(signals) {
var actions = [];
var clsSignals = classifySignals(signals);
// Initial bus state
var buses = {
aluOut: '0',
iBus1: 'HiZ',
iBus2: 'HiZ',
iBus3: 'HiZ',
mdrI: 'HiZ'
};
// Calculate memory-related values
var memoryAction = calculateMemory(clsSignals, buses);
if (memoryAction) {
actions.push(memoryAction);
}
// Calculate independent register bus output values
calculateIndependentBusOutput(clsSignals, buses);
// Calculate bus output values that depend on each other
calculateDependentBusOutput(clsSignals, buses);
// All signals are calculated, decide which actions these signals result in
actions = actions.concat(executeActions(clsSignals, buses));
return actions;
}

window.mw = $.extend(true, window.mw, {
libs: {
diagramGenerator: {
signalsToActions: main
}
}
});
})();