Skip to content

refactor(finite_automata): Update RegisterHandler API for the initial simulation implementation: #110

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
+33 −68
Open

refactor(finite_automata): Update RegisterHandler API for the initial simulation implementation: #110

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
e9bf1ba
Rework how registers work.
SharafMohamed May 12, 2025
3010f6e
Merge branch 'main' into simulation-register-handler
SharafMohamed May 21, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
19 changes: 3 additions & 16 deletions src/log_surgeon/finite_automata/RegisterHandler.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,25 +27,10 @@ class RegisterHandler {
}

auto add_register() -> reg_id_t {
auto const prefix_tree_node_id{
m_prefix_tree.insert(PrefixTree::cRootId, PrefixTree::cDefaultPos)
};
m_registers.emplace_back(prefix_tree_node_id);
m_registers.emplace_back(PrefixTree::cRootId);
return m_registers.size() - 1;
}

auto add_register(PrefixTree::id_t const prefix_tree_parent_node_id) -> reg_id_t {
auto const prefix_tree_node_id{
m_prefix_tree.insert(prefix_tree_parent_node_id, PrefixTree::cDefaultPos)
};
m_registers.emplace_back(prefix_tree_node_id);
return m_registers.size() - 1;
}

auto set_register(reg_id_t const reg_id, PrefixTree::position_t const position) -> void {
m_prefix_tree.set(m_registers.at(reg_id), position);
}

auto copy_register(reg_id_t const dest_reg_id, reg_id_t const source_reg_id) -> void {
m_registers.at(dest_reg_id) = m_registers.at(source_reg_id);
}
Expand All @@ -60,6 +45,8 @@ class RegisterHandler {
return m_prefix_tree.get_reversed_positions(m_registers.at(reg_id));
}

[[nodiscard]] auto get_num_regs() const -> size_t { return m_registers.size(); }

private:
PrefixTree m_prefix_tree;
std::vector<PrefixTree::id_t> m_registers;
Expand Down
82 changes: 30 additions & 52 deletions tests/test-register-handler.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,14 +19,7 @@ namespace {

auto handler_init(size_t const num_registers) -> RegisterHandler {
RegisterHandler handler;
if (0 == num_registers) {
return handler;
}

handler.add_register();
for (size_t i{1}; i < num_registers; ++i) {
handler.add_register(i);
}
handler.add_registers(num_registers);
return handler;
}
} // namespace
Expand All @@ -36,66 +29,51 @@ TEST_CASE("`RegisterHandler` tests", "[RegisterHandler]") {
constexpr size_t cNumRegisters{5};
constexpr size_t cRegId1{0};
constexpr size_t cRegId2{1};

SECTION("Initial state is empty") {
RegisterHandler const empty_handler{handler_init(0)};
REQUIRE_THROWS_AS(empty_handler.get_reversed_positions(cRegId1), std::out_of_range);
}
constexpr position_t cAppendPos1{5};
constexpr position_t cAppendPos2{10};
constexpr position_t cAppendPos3{15};

RegisterHandler handler{handler_init(cNumRegisters)};

SECTION("Set register position correctly") {
handler.set_register(cRegId1, cInitialPos1);
REQUIRE(std::vector<position_t>{cInitialPos1} == handler.get_reversed_positions(cRegId1));
}

SECTION("Register relationships are maintained") {
constexpr position_t cInitialPos2{10};
constexpr position_t cInitialPos3{15};
constexpr size_t cRegId3{2};

handler.set_register(cRegId1, cInitialPos1);
handler.set_register(cRegId2, cInitialPos2);
handler.set_register(cRegId3, cInitialPos3);
SECTION("Throws out of range correctly") {
constexpr size_t cInvalidRegId{10};
RegisterHandler const empty_handler{handler_init(0)};

auto positions{handler.get_reversed_positions(cRegId3)};
REQUIRE(std::vector<position_t>{cInitialPos3, cInitialPos2, cInitialPos1}
== handler.get_reversed_positions(cRegId3));
REQUIRE_THROWS_AS(empty_handler.get_reversed_positions(cRegId1), std::out_of_range);
REQUIRE_THROWS_AS(handler.copy_register(cInvalidRegId, cRegId2), std::out_of_range);
REQUIRE_THROWS_AS(handler.copy_register(cRegId1, cInvalidRegId), std::out_of_range);
REQUIRE_THROWS_AS(handler.append_position(cInvalidRegId, cInitialPos1), std::out_of_range);
REQUIRE_THROWS_AS(handler.get_reversed_positions(cInvalidRegId), std::out_of_range);
}

SECTION("Copy register index correctly") {
handler.set_register(cRegId1, cInitialPos1);
SECTION("Initial register is empty") {
auto positions{handler.get_reversed_positions(cRegId1)};
REQUIRE(handler.get_reversed_positions(cRegId1).empty());

handler.copy_register(cRegId2, cRegId1);
REQUIRE(std::vector<position_t>{cInitialPos1} == handler.get_reversed_positions(cRegId2));
REQUIRE(handler.get_reversed_positions(cRegId2).empty());
}

SECTION("`append_position` appends position correctly") {
constexpr position_t cAppendPos{10};

handler.set_register(cRegId1, cInitialPos1);
handler.append_position(cRegId1, cAppendPos);
REQUIRE(std::vector<position_t>{cAppendPos, cInitialPos1}
SECTION("Append and copy position work correctly") {
handler.append_position(cRegId1, cAppendPos1);
handler.append_position(cRegId1, cAppendPos2);
handler.append_position(cRegId1, cAppendPos3);
REQUIRE(std::vector<position_t>{cAppendPos3, cAppendPos2, cAppendPos1}
== handler.get_reversed_positions(cRegId1));
}

SECTION("Throws out of range correctly") {
constexpr size_t cInvalidRegId{10};

REQUIRE_THROWS_AS(handler.set_register(cInvalidRegId, cInitialPos1), std::out_of_range);
REQUIRE_THROWS_AS(handler.copy_register(cInvalidRegId, cRegId2), std::out_of_range);
REQUIRE_THROWS_AS(handler.copy_register(cRegId1, cInvalidRegId), std::out_of_range);
REQUIRE_THROWS_AS(handler.append_position(cInvalidRegId, cInitialPos1), std::out_of_range);
REQUIRE_THROWS_AS(handler.get_reversed_positions(cInvalidRegId), std::out_of_range);
handler.copy_register(cRegId2, cRegId1);
REQUIRE(std::vector<position_t>{cAppendPos3, cAppendPos2, cAppendPos1}
== handler.get_reversed_positions(cRegId2));
}

SECTION("Handles negative position values correctly") {
constexpr size_t cRegId3{2};
constexpr position_t cNegativePos1{-1};
constexpr position_t cNegativePos2{-100};

handler.set_register(cRegId1, cNegativePos1);
handler.append_position(cRegId1, cInitialPos1);
handler.append_position(cRegId1, cNegativePos2);
REQUIRE(std::vector<position_t>{cNegativePos2, cInitialPos1, cNegativePos1}
== handler.get_reversed_positions(cRegId1));
handler.append_position(cRegId3, cNegativePos1);
handler.append_position(cRegId3, cNegativePos2);
REQUIRE(std::vector<position_t>{cNegativePos2, cNegativePos1}
== handler.get_reversed_positions(cRegId3));
}
}
Loading