Merge branch 'main' of https://github.com/Martian-Technologies/Connection-Machine

Author: ItchyTrack

src/backend/evaluator/evaluator.cpp

@@ -147,6 +147,7 @@ void Evaluator::edit_removeBlock(
 		logError("Node at position {} not found", "Evaluator::edit_removeBlock", position.toString());
 		return;
 	}
+	circuitNodeToBlockTypeMap.erase(node.value());
 	removeDependentInterCircuitConnections(pauseGuard, node.value());
 	if (node->isIC()) {
 		eval_circuit_id_t icId = node->getEvalCircuitId();
@@ -209,6 +210,7 @@ void Evaluator::edit_placeBlock(
 	}
 	CircuitNode node = CircuitNode::fromMiddle(gateId);
 	evalCircuit->setNode(position, node);
+	circuitNodeToBlockTypeMap[node] = blockType;
 	dirtyBlockAt(position, evalCircuitId);
 	checkToCreateExternalConnections(pauseGuard, evalCircuitId, position);
 }
@@ -286,12 +288,49 @@ void Evaluator::edit_createConnection(
 		return;
 	}
 	EvalConnection connection(outputPoint.value(), inputPoint.value());
+
+	// if (!checkIfBitWidthsMatch(connection)) {
+	// 	return;
+	// }
+
 	if (!circuitPortDependencies.empty() || !circuitNodeDependencies.empty()) {
 		interCircuitConnections.push_back({ connection, circuitPortDependencies, circuitNodeDependencies });
 	}
 	evalSimulator->makeConnection(pauseGuard, connection);
 }
 
+// bool Evaluator::checkIfBitWidthsMatch(
+// 	const EvalConnection& connection
+// ) const {
+// 	CircuitNode outputNode = CircuitNode::fromMiddle(connection.source.gateId);
+// 	CircuitNode inputNode = CircuitNode::fromMiddle(connection.destination.gateId);
+// 	if (!circuitNodeToBlockTypeMap.contains(outputNode) || !circuitNodeToBlockTypeMap.contains(inputNode)) {
+// 		logError("CircuitNode not found in circuitNodeToBlockTypeMap", "Evaluator::checkIfBitWidthsMatch");
+// 		return false;
+// 	}
+// 	BlockType outputBlockType = circuitNodeToBlockTypeMap.at(outputNode);
+// 	unsigned int outputBitWidth;
+// 	if (outputBlockType == BlockType::SWITCH || outputBlockType == BlockType::BUTTON || outputBlockType == BlockType::TICK_BUTTON) {
+// 		outputBitWidth = 1;
+// 	} else {
+// 		BlockData* outputBlockData = blockDataManager.getBlockData(outputBlockType);
+// 		connection_end_id_t outputConnectionEndId = connection.source.portId;
+// 		outputBitWidth = outputBlockData->getConnectionBitWidth(outputConnectionEndId);
+// 	}
+
+// 	BlockType inputBlockType = circuitNodeToBlockTypeMap.at(inputNode);
+// 	unsigned int inputBitWidth;
+// 	if (inputBlockType == BlockType::LIGHT) {
+// 		inputBitWidth = 1;
+// 	} else{
+// 		BlockData* inputBlockData = blockDataManager.getBlockData(inputBlockType);
+// 		connection_end_id_t inputConnectionEndId = connection.destination.portId;
+// 		inputBitWidth = inputBlockData->getConnectionBitWidth(inputConnectionEndId);
+// 	}
+
+// 	return outputBitWidth == inputBitWidth;
+// }
+
 void Evaluator::removeDependentInterCircuitConnections(SimPauseGuard& pauseGuard, CircuitPortDependency circuitPortDependency) {
 	// delete any connections that have the pair {circuitId, connectionEndId} in their traceSet
 	for (auto it = interCircuitConnections.begin(); it != interCircuitConnections.end();) {
@@ -999,8 +1038,10 @@ void Evaluator::traceOutwardsIC(
 			} else {
 				evalConnection = EvalConnection(targetConnectionPoint, connectionPoint.value());
 			}
+			// if (checkIfBitWidthsMatch(evalConnection)) {
 			evalSimulator->makeConnection(pauseGuard, evalConnection);
 			interCircuitConnections.push_back({ evalConnection, circuitPortDependenciesCopy, circuitNodeDependenciesCopy });
+			// }
 
 			traceOutwardsIC(
 				pauseGuard,

src/backend/evaluator/evaluator.h

@@ -175,6 +175,7 @@ class Evaluator {
 	std::unordered_set<EvalPosition> dirtyNodes;
 	std::unordered_multimap<simulator_id_t, EvalPosition> pinSimulatorIdToEvalPositionMap;
 	std::unordered_map<middle_id_t, EvalPosition> middleIdToEvalPositionMap;
+	std::unordered_map<CircuitNode, BlockType> circuitNodeToBlockTypeMap;
 
 	std::map<void*, SimulatorMappingUpdateListener> listeners;
 	void sendSimulatorMappingUpdate(eval_circuit_id_t targetEvalCircuitId, const std::vector<SimulatorMappingUpdate>& updates) {
@@ -187,6 +188,9 @@ class Evaluator {
 
 	void processDirtyNodes();
 	void dirtyBlockAt(Position position, eval_circuit_id_t evalCircuitId);
+	bool checkIfBitWidthsMatch(
+		const EvalConnection& connection
+	) const;
 
 	mutable std::shared_mutex simMutex;
 };

src/backend/evaluator/layers/layer4_replacer.cpp

@@ -180,6 +180,9 @@ void Replacer::mergeBusLane(SimPauseGuard& pauseGuard, int layer, int junctionOv
 			if (sourceBlockType != BlockType::JUNCTION) {
 				const BlockData* sourceBlockData = blockDataManager.getBlockData(sourceBlockType);
 				const BlockData::ConnectionData* sourceConnectionData = sourceBlockData->getConnectionData(input.source.portId);
+				if (!sourceConnectionData) {
+					continue;
+				}
 				sourceLaneId = sourceConnectionData->getLaneId(connectionLaneIndex);
 			}
 			BlockLane sourceLane = { sourceBlockId, sourceLaneId };
@@ -214,6 +217,9 @@ void Replacer::mergeBusLane(SimPauseGuard& pauseGuard, int layer, int junctionOv
 			if (destBlockType != BlockType::JUNCTION) {
 				const BlockData* destBlockData = blockDataManager.getBlockData(destBlockType);
 				const BlockData::ConnectionData* destConnectionData = destBlockData->getConnectionData(output.destination.portId);
+				if (!destConnectionData) {
+					continue;
+				}
 				destLaneId = destConnectionData->getLaneId(connectionLaneIndex);
 			}
 			BlockLane destLane = { destBlockId, destLaneId };

src/backend/evaluator/util/circuitNode.h

@@ -35,4 +35,13 @@ class CircuitNode {
 	unsigned int id_and_type;
 };
 
+namespace std {
+	template<>
+	struct hash<CircuitNode> {
+		size_t operator()(const CircuitNode& node) const noexcept {
+			return std::hash<unsigned int>()(node.isIC() ? (node.getEvalCircuitId().get() << 1) | 1 : (node.getMiddleId().get() << 1));
+		}
+	};
+}
+
 #endif /* circuitNode_h */