Skip to content

Commit e376494

Browse files
ItchyTrackItchyTrack
committed
improved sim mapping update
1 parent c34a1e3 commit e376494

File tree

9 files changed

+106
-77
lines changed

9 files changed

+106
-77
lines changed

‎src/backend/evaluator/evalDefs.h‎

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -9,15 +9,9 @@ DECLARE_ID_TYPE(eval_circuit_id_t, unsigned int);
99
DECLARE_ID_TYPE(middle_id_t, unsigned int);
1010
DECLARE_ID_TYPE(simulator_id_t, unsigned int);
1111

12-
enum class SimulatorMappingUpdateType {
13-
BLOCK,
14-
PIN
15-
};
16-
1712
struct SimulatorMappingUpdate {
1813
Position portPosition;
1914
std::variant<simulator_id_t, std::vector<simulator_id_t>> simulatorIds;
20-
SimulatorMappingUpdateType type;
2115
};
2216

2317
typedef std::function<void(const std::vector<SimulatorMappingUpdate>&)> SimulatorMappingUpdateListenerFunction;
@@ -31,6 +25,7 @@ enum class Direction {
3125
IN,
3226
OUT,
3327
};
28+
3429
inline Direction operator!(Direction dir) {
3530
return (dir == Direction::IN) ? Direction::OUT : Direction::IN;
3631
}

‎src/backend/evaluator/evaluator.cpp‎

Lines changed: 15 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,8 @@
11
#include "evaluator.h"
22

33
#include "backend/circuit/circuitManager.h"
4-
#include "util/algorithm.h"
5-
#include "util/id.h"
64
#include "layers/layer2_evalSimulator.h"
5+
#include "util/id.h"
76

87
#ifdef TRACY_PROFILER
98
#include <tracy/Tracy.hpp>
@@ -1256,7 +1255,7 @@ void Evaluator::processDirtyNodes() {
12561255
for (int i = 0; i < dirtyPointsToProcess.size(); ++i) {
12571256
const EvalPosition& evalPosition = dirtyPointsToProcess.at(i);
12581257
std::variant<simulator_id_t, std::vector<simulator_id_t>> pinSimId = pinSimIds.at(i);
1259-
simulatorMappingUpdates[evalPosition.evalCircuitId].push_back({ evalPosition.position, pinSimId, SimulatorMappingUpdateType::PIN });
1258+
simulatorMappingUpdates[evalPosition.evalCircuitId].push_back({ evalPosition.position, pinSimId });
12601259
if (std::holds_alternative<simulator_id_t>(pinSimId)) {
12611260
simulator_id_t singlePinSimId = std::get<simulator_id_t>(pinSimId);
12621261
pinSimulatorIdToEvalPositionMap.insert({ singlePinSimId, evalPosition });
@@ -1274,19 +1273,19 @@ void Evaluator::processDirtyNodes() {
12741273
// std::to_string(pinSimId)
12751274
// );
12761275
}
1277-
for (int i = 0; i < blocksToGatherBlockSimIds.size(); ++i) {
1278-
const EvalConnectionPoint& blockPoint = blocksToGatherBlockSimIds.at(i);
1279-
simulator_id_t blockSimId = blockSimIds.at(i);
1280-
EvalPosition evalPosition = middleIdToEvalPositionMap.at(blockPoint.gateId);
1281-
simulatorMappingUpdates[evalPosition.evalCircuitId].push_back({ evalPosition.position, blockSimId, SimulatorMappingUpdateType::BLOCK });
1282-
// logInfo(
1283-
// "Processed dirty block at evalCircuitId {}, position {}, simulatorId {}",
1284-
// "Evaluator::processDirtyNodes",
1285-
// evalPosition.evalCircuitId,
1286-
// evalPosition.position.toString(),
1287-
// std::to_string(blockSimId)
1288-
// );
1289-
}
1276+
// for (int i = 0; i < blocksToGatherBlockSimIds.size(); ++i) {
1277+
// const EvalConnectionPoint& blockPoint = blocksToGatherBlockSimIds.at(i);
1278+
// simulator_id_t blockSimId = blockSimIds.at(i);
1279+
// EvalPosition evalPosition = middleIdToEvalPositionMap.at(blockPoint.gateId);
1280+
// simulatorMappingUpdates[evalPosition.evalCircuitId].push_back({ evalPosition.position, blockSimId, SimulatorMappingUpdateType::BLOCK });
1281+
// // logInfo(
1282+
// // "Processed dirty block at evalCircuitId {}, position {}, simulatorId {}",
1283+
// // "Evaluator::processDirtyNodes",
1284+
// // evalPosition.evalCircuitId,
1285+
// // evalPosition.position.toString(),
1286+
// // std::to_string(blockSimId)
1287+
// // );
1288+
// }
12901289

12911290
{
12921291
#ifdef TRACY_PROFILER

‎src/environment/blockRenderDataFeeder.cpp‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,20 @@ void BlockRenderDataFeeder::newBlockTypeUpdate(const DataUpdateEventManager::Eve
4040
blockTypeToRenderData.emplace(data->get(), blockRenderDataId);
4141

4242
blockTexturesToUpdate.insert(data->get());
43+
44+
switch (data->get()) {
45+
case BlockType::JUNCTION_H:
46+
case BlockType::JUNCTION_L:
47+
case BlockType::JUNCTION_X:
48+
MainRenderer::get().setBlockStatePortPosition(blockRenderDataId, Vector(0, 2));
49+
break;
50+
case BlockType::TRISTATE_BUFFER:
51+
MainRenderer::get().setBlockStatePortPosition(blockRenderDataId, Vector(0, 1));
52+
break;
53+
default:
54+
MainRenderer::get().setBlockStatePortPosition(blockRenderDataId, Vector(0, 0)); // may need to change
55+
break;
56+
}
4357
}
4458

4559
void BlockRenderDataFeeder::postBlockSizeChangeUpdate(const DataUpdateEventManager::EventData* dataEvent) {

‎src/gpu/blockRenderDataManager.cpp‎

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
#include "util/algorithm.h"
44
#include "mainRenderer.h"
55

6-
const BlockRenderDataManager::BlockRenderData* BlockRenderDataManager::getBlockRenderData(BlockRenderDataId blockRenderDataId) {
6+
const BlockRenderDataManager::BlockRenderData* BlockRenderDataManager::getBlockRenderData(BlockRenderDataId blockRenderDataId) const {
77
auto iter = blockRenderData.find(blockRenderDataId);
88
if (iter == blockRenderData.end()) {
99
logError("Failed to get BlockRenderData with BlockRenderDataId {}.", "BlockRenderDataManager", blockRenderDataId);
@@ -140,3 +140,12 @@ void BlockRenderDataManager::setBlockPortName(BlockRenderDataId blockRenderDataI
140140
}
141141
portIter->second.portName = newPortName;
142142
}
143+
144+
void BlockRenderDataManager::setBlockStatePortPosition(BlockRenderDataId blockRenderDataId, Vector blockStatePortPosition) {
145+
auto iter = blockRenderData.find(blockRenderDataId);
146+
if (iter == blockRenderData.end()) {
147+
logError("Failed to call setBlockStatePort on non existent BlockRenderData {}.", "BlockRenderDataManager", blockRenderDataId);
148+
return;
149+
}
150+
iter->second.blockStatePortPosition = blockStatePortPosition;
151+
}

‎src/gpu/blockRenderDataManager.h‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,9 +20,10 @@ class BlockRenderDataManager {
2020
Size size = Size(1);
2121
BlockTextureCords blockTextureCords = BlockTextureCords({0, 0}, {1, 1}, 0, {0, 0});
2222
std::map<BlockPortRenderDataId, BlockPortRenderData> blockPortRenderData;
23+
std::optional<Vector> blockStatePortPosition;
2324
};
2425

25-
const BlockRenderData* getBlockRenderData(BlockRenderDataId blockRenderDataId);
26+
const BlockRenderData* getBlockRenderData(BlockRenderDataId blockRenderDataId) const;
2627

2728
BlockRenderDataId addBlockRenderData();
2829
void removeBlockRenderData(BlockRenderDataId blockRenderDataId);
@@ -35,6 +36,7 @@ class BlockRenderDataManager {
3536
void removeBlockPort(BlockRenderDataId blockRenderDataId, BlockPortRenderDataId blockPortRenderDataId);
3637
void moveBlockPort(BlockRenderDataId blockRenderDataId, BlockPortRenderDataId blockPortRenderDataId, FVector newPositionOnBlock);
3738
void setBlockPortName(BlockRenderDataId blockRenderDataId, BlockPortRenderDataId blockPortRenderDataId, const std::string newPortName);
39+
void setBlockStatePortPosition(BlockRenderDataId blockRenderDataId, Vector blockStatePortPosition);
3840

3941
private:
4042
std::map<BlockRenderDataId, BlockRenderData> blockRenderData;

‎src/gpu/mainRenderer.cpp‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -207,6 +207,10 @@ void MainRenderer::setBlockPortName(BlockRenderDataId blockRenderDataId, BlockPo
207207
blockRenderDataManager.setBlockPortName(blockRenderDataId, blockPortRenderDataId, newPortName);
208208
}
209209

210+
void MainRenderer::setBlockStatePortPosition(BlockRenderDataId blockRenderDataId, Vector blockStatePortPosition) {
211+
blockRenderDataManager.setBlockStatePortPosition(blockRenderDataId, blockStatePortPosition);
212+
}
213+
210214
void MainRenderer::regenerateAllChunksWithBlock(BlockRenderDataId blockRenderDataId) {
211215
for (std::pair<const unsigned int, ViewportRenderData>& pair : viewportRenderers) {
212216
pair.second.getChunker().regenerateAllChunksWithBlock(blockRenderDataId);

‎src/gpu/mainRenderer.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -69,6 +69,7 @@ class MainRenderer {
6969
void removeBlockPort(BlockRenderDataId blockRenderDataId, BlockPortRenderDataId blockPortRenderDataId);
7070
void moveBlockPort(BlockRenderDataId blockRenderDataId, BlockPortRenderDataId blockPortRenderDataId, FVector newPositionOnBlock);
7171
void setBlockPortName(BlockRenderDataId blockRenderDataId, BlockPortRenderDataId blockPortRenderDataId, const std::string& newPortName);
72+
void setBlockStatePortPosition(BlockRenderDataId blockRenderDataId, Vector blockStatePortPosition);
7273
void regenerateAllChunksWithBlock(BlockRenderDataId blockRenderDataId);
7374

7475

‎src/gpu/renderer/viewport/logic/chunking/vulkanChunker.cpp‎

Lines changed: 51 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -326,6 +326,12 @@ void VulkanChunker::addBlock(BlockRenderDataId blockRenderDataId, Position posit
326326
(orientation * blockRenderData->size).free()
327327
)
328328
);
329+
if (blockRenderData->blockStatePortPosition) {
330+
logicGroup.getBlockStatePortMapping().try_emplace(position + orientation.transformVectorWithArea(
331+
blockRenderData->blockStatePortPosition.value(),
332+
blockRenderData->size
333+
), position);
334+
}
329335
if (newGroup) {
330336
for (auto chunkPosIter = getChunk(position).iterTo(getChunk(position + (orientation * blockRenderData->size).getLargestVectorInArea())); chunkPosIter;
331337
++chunkPosIter) {
@@ -346,6 +352,13 @@ void VulkanChunker::removeBlock(Position position) {
346352
for (LogicGroup* logicGroup : groupsAtChunkIter->second) {
347353
auto blockIter = logicGroup->getRenderedBlocks().find(position);
348354
if (blockIter == logicGroup->getRenderedBlocks().end()) continue;
355+
const BlockRenderDataManager::BlockRenderData* blockRenderData = MainRenderer::get().getBlockRenderDataManager().getBlockRenderData(blockIter->second.blockRenderDataId);
356+
if (blockRenderData->blockStatePortPosition) {
357+
logicGroup->getBlockStatePortMapping().erase(position + blockIter->second.orientation.transformVectorWithArea(
358+
blockRenderData->blockStatePortPosition.value(),
359+
blockRenderData->size
360+
));
361+
}
349362
logicGroup->getRenderedBlocks().erase(blockIter);
350363
logicGroupsToUpdate.insert(logicGroup);
351364
return;
@@ -456,62 +469,51 @@ void VulkanChunker::updateSimulatorIds(const std::vector<SimulatorMappingUpdate>
456469
for (const SimulatorMappingUpdate& simulatorMappingUpdate : simulatorMappingUpdates) {
457470
const std::variant<simulator_id_t, std::vector<simulator_id_t>>& simIds = simulatorMappingUpdate.simulatorIds;
458471

459-
if (simulatorMappingUpdate.type == SimulatorMappingUpdateType::BLOCK) {
460-
simulator_id_t simulatorId = simulator_id_t(0);
472+
Position chunkPos = getChunk(simulatorMappingUpdate.portPosition);
473+
auto groupsAtChunkIter = chunkToGroups.find(chunkPos);
474+
if (groupsAtChunkIter == chunkToGroups.end()) {
475+
continue;
476+
}
477+
for (LogicGroup* logicGroup : groupsAtChunkIter->second) {
478+
std::optional<std::shared_ptr<VulkanLogicAllocation>> vulkanLogicAllocation = logicGroup->getAllocation();
479+
if (!vulkanLogicAllocation) continue;
480+
auto blockPosIter = logicGroup->getBlockStatePortMapping().find(simulatorMappingUpdate.portPosition);
481+
if (blockPosIter == logicGroup->getBlockStatePortMapping().end()) continue;
482+
auto iter = vulkanLogicAllocation.value()->getBlockStateIndex().find(blockPosIter->second);
483+
if (iter == vulkanLogicAllocation.value()->getBlockStateIndex().end()) continue;
461484
if (std::holds_alternative<std::vector<simulator_id_t>>(simIds)) {
462-
const std::vector<simulator_id_t>& vec = std::get<std::vector<simulator_id_t>>(simIds);
463-
if (!vec.empty()) {
464-
simulatorId = vec[0];
465-
}
485+
vulkanLogicAllocation.value()->getStateSimulatorIds()[iter->second] = 0;
466486
} else {
467-
simulatorId = std::get<simulator_id_t>(simIds);
487+
vulkanLogicAllocation.value()->getStateSimulatorIds()[iter->second] = std::get<simulator_id_t>(simIds);
468488
}
489+
break;
490+
}
491+
for (LogicGroup* logicGroup : groupsAtChunkIter->second) {
492+
std::optional<std::shared_ptr<VulkanLogicAllocation>> vulkanLogicAllocation = logicGroup->getAllocation();
493+
if (!vulkanLogicAllocation) continue;
494+
auto portStateIter = vulkanLogicAllocation.value()->getPortStateIndex().find(simulatorMappingUpdate.portPosition);
495+
if (portStateIter == vulkanLogicAllocation.value()->getPortStateIndex().end()) continue;
469496

470-
Position chunkPos = getChunk(simulatorMappingUpdate.portPosition);
471-
auto groupsAtChunkIter = chunkToGroups.find(chunkPos);
472-
if (groupsAtChunkIter == chunkToGroups.end()) {
473-
continue;
474-
}
475-
for (LogicGroup* logicGroup : groupsAtChunkIter->second) {
476-
std::optional<std::shared_ptr<VulkanLogicAllocation>> vulkanLogicAllocation = logicGroup->getAllocation();
477-
if (!vulkanLogicAllocation) continue;
478-
auto iter = vulkanLogicAllocation.value()->getBlockStateIndex().find(simulatorMappingUpdate.portPosition);
479-
if (iter == vulkanLogicAllocation.value()->getBlockStateIndex().end()) continue;
480-
vulkanLogicAllocation.value()->getStateSimulatorIds()[iter->second] = simulatorId;
481-
}
482-
} else {
483-
Position chunkPos = getChunk(simulatorMappingUpdate.portPosition);
484-
auto groupsAtChunkIter = chunkToGroups.find(chunkPos);
485-
if (groupsAtChunkIter == chunkToGroups.end()) {
486-
continue;
487-
}
488-
for (LogicGroup* logicGroup : groupsAtChunkIter->second) {
489-
std::optional<std::shared_ptr<VulkanLogicAllocation>> vulkanLogicAllocation = logicGroup->getAllocation();
490-
if (!vulkanLogicAllocation) continue;
491-
auto portStateIter = vulkanLogicAllocation.value()->getPortStateIndex().find(simulatorMappingUpdate.portPosition);
492-
if (portStateIter == vulkanLogicAllocation.value()->getPortStateIndex().end()) continue;
493-
494-
const PortStateRange& range = portStateIter->second;
495-
if (!range.isValid()) continue;
496-
497-
std::vector<simulator_id_t>& chunkStateSimulatorIds = vulkanLogicAllocation.value()->getStateSimulatorIds();
498-
if (std::holds_alternative<std::vector<simulator_id_t>>(simIds)) {
499-
const std::vector<simulator_id_t>& wireSimIds = std::get<std::vector<simulator_id_t>>(simIds);
500-
uint32_t laneCount = wireSimIds.size();
501-
if (laneCount != range.laneCount) {
502-
logicGroupsToUpdate.insert(logicGroup);
503-
} else {
504-
for (uint32_t lane = 0; lane < laneCount; lane++) {
505-
chunkStateSimulatorIds[range.baseIndex + lane] = wireSimIds[lane];
506-
}
507-
}
497+
const PortStateRange& range = portStateIter->second;
498+
if (!range.isValid()) continue;
499+
500+
std::vector<simulator_id_t>& chunkStateSimulatorIds = vulkanLogicAllocation.value()->getStateSimulatorIds();
501+
if (std::holds_alternative<std::vector<simulator_id_t>>(simIds)) {
502+
const std::vector<simulator_id_t>& wireSimIds = std::get<std::vector<simulator_id_t>>(simIds);
503+
uint32_t laneCount = wireSimIds.size();
504+
if (laneCount != range.laneCount) {
505+
logicGroupsToUpdate.insert(logicGroup);
508506
} else {
509-
if (1 != range.laneCount) {
510-
logicGroupsToUpdate.insert(logicGroup);
511-
} else {
512-
chunkStateSimulatorIds[range.baseIndex] = std::get<simulator_id_t>(simIds);
507+
for (uint32_t lane = 0; lane < laneCount; lane++) {
508+
chunkStateSimulatorIds[range.baseIndex + lane] = wireSimIds[lane];
513509
}
514510
}
511+
} else {
512+
if (1 != range.laneCount) {
513+
logicGroupsToUpdate.insert(logicGroup);
514+
} else {
515+
chunkStateSimulatorIds[range.baseIndex] = std::get<simulator_id_t>(simIds);
516+
}
515517
}
516518
}
517519
}

‎src/gpu/renderer/viewport/logic/chunking/vulkanChunker.h‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@
1313
#include "gpu/helper/nBuffer.h"
1414

1515
class SimulatorMappingUpdate;
16+
class BlockRenderDataManager;
1617

1718
// ====================================================================================================================
1819

@@ -32,8 +33,8 @@ struct BlockInstance {
3233
bindingDescriptions[0].stride = sizeof(BlockInstance);
3334
bindingDescriptions[0].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
3435

35-
return bindingDescriptions;
36-
}
36+
return bindingDescriptions;
37+
}
3738

3839
inline static std::vector<VkVertexInputAttributeDescription> getAttributeDescriptions() {
3940
std::vector<VkVertexInputAttributeDescription> attributeDescriptions(7);
@@ -89,8 +90,8 @@ struct WireInstance {
8990
bindingDescriptions[0].stride = sizeof(WireInstance);
9091
bindingDescriptions[0].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
9192

92-
return bindingDescriptions;
93-
}
93+
return bindingDescriptions;
94+
}
9495

9596
inline static std::vector<VkVertexInputAttributeDescription> getAttributeDescriptions() {
9697
std::vector<VkVertexInputAttributeDescription> attributeDescriptions(4);
@@ -187,6 +188,7 @@ class VulkanLogicAllocation {
187188
class LogicGroup {
188189
public:
189190
inline RenderedBlocks& getRenderedBlocks() { return blocks; }
191+
inline std::unordered_map<Position, Position>& getBlockStatePortMapping() { return blockStatePortMapping; }
190192
inline RenderedWires& getRenderedWires() { return wires; }
191193
void rebuildAllocation(VulkanDevice* device, const Evaluator* evaluator, const Address& address);
192194

@@ -198,6 +200,7 @@ class LogicGroup {
198200
private:
199201
RenderedBlocks blocks;
200202
RenderedWires wires;
203+
std::unordered_map<Position, Position> blockStatePortMapping;
201204

202205
std::optional<std::shared_ptr<VulkanLogicAllocation>> newestAllocation;
203206
std::optional<std::shared_ptr<VulkanLogicAllocation>> currentlyAllocating;

0 commit comments

Comments
 (0)