Skip to content

Commit 97afabb

Browse files
anyaevostinaranyaevostinar
authored
Merge pull request #311 from EliasH-E/jump-fix
Fixed jumps and anchors in Genome Printing
2 parents b34220c + ec1db9c commit 97afabb

4 files changed

Lines changed: 205 additions & 5 deletions

File tree

‎source/sgp_mode/hardware/GenomeLibrary.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ namespace lib_info {
5252
{"Reproduce", 0}, {"PrivateIO", 1}, {"SharedIO", 1}, {"Donate", 0},
5353
{"Reuptake", 1}, {"Steal", 0}, {"Infect", 0}, {"DynamicInst", 3},
5454
{"SenseTask", 2},
55-
{"IO", 1}, {"JumpIfNEq", 2}, {"JumpIfEq", 2}, {"JumpIfLess", 2}
55+
{"IO", 1}
5656
};
5757
}
5858

‎source/sgp_mode/hardware/Instructions.h‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,6 @@ INST(Reproduce, {
130130
state.MarkReproAttempt();
131131
});
132132

133-
// NOTE - what is the intended difference between SharedIO and PrivateIO?
134133
INST(IO, {
135134
// (1) Add output to output buffer
136135
state.GetOutputBuffer().emplace_back(a);

‎source/sgp_mode/hardware/SGPHardware.h‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -303,16 +303,18 @@ void SGPHardware<HW_SPEC_T>::PrintOp(
303303
} else {
304304
tag_name = "<nowhere>";
305305
}
306-
307-
if (name == "JumpIfNEq" || name == "JumpIfLess") {
306+
307+
if (name == "JumpIfNEq" || name == "JumpIfLess" || name == "JumpIfEq") {
308+
308309
out << " " << emp::to_lower(name);
309310
for (size_t i = 0; i < 12 - name.length(); i++) {
310311
out << ' ';
311312
}
312313
out << 'r' << (int)ins.args[0] << ", r" << (int)ins.args[1] << ", "
313314
<< tag_name;
315+
314316
} else if (name == "Global Anchor") {
315-
out << tag_name << " " << ins.tag << ':';
317+
out << tag_name << ':';
316318
} else {
317319
out << "<unknown " << name << ">";
318320
}

‎source/test/sgp_mode_test/unit_tests/SGPHardware.test.cc‎

Lines changed: 199 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,199 @@
1+
#include "emp/math/Random.hpp"
2+
3+
#include "../../../sgp_mode/hardware/SGPHardware.h"
4+
#include "../../../sgp_mode/SGPWorld.h"
5+
#include "../../../sgp_mode/SGPWorld.cc"
6+
#include "../../../sgp_mode/SGPWorldSetup.cc"
7+
#include "../../../sgp_mode/SGPWorldData.cc"
8+
#include "../../../sgp_mode/ProgramBuilder.h"
9+
10+
#include "../../../catch/catch.hpp"
11+
12+
#include <array>
13+
#include <string>
14+
15+
TEST_CASE("Test Printing Simple Instructions", "[sgp]"){
16+
using world_t = sgpmode::SGPWorld;
17+
using cpu_state_t = sgpmode::CPUState<world_t>;
18+
using hw_spec_t = sgpmode::SGPHardwareSpec<sgpmode::Library, cpu_state_t, world_t>;
19+
using hardware_t = sgpmode::SGPHardware<hw_spec_t>;
20+
using program_t = typename world_t::sgp_prog_t;
21+
using sgp_host_t = sgpmode::SGPHost<hw_spec_t>;
22+
using tag_t = typename hw_spec_t::tag_t;
23+
24+
sgpmode::SymConfigSGP config;
25+
config.CYCLES_PER_UPDATE(0);
26+
config.HOST_REPRO_RES(1);
27+
config.SEED(61);
28+
config.TASK_ENV_CFG_PATH("source/test/sgp_mode_test/hardware-test-env.json");
29+
config.FILE_PATH("hardware_test_output");
30+
config.POP_SIZE(1);
31+
config.START_MOI(0);
32+
config.TASK_IO_UNIQUE_OUTPUT(true);
33+
34+
emp::Random random(config.SEED());
35+
world_t world(random, &config);
36+
world.Setup();
37+
auto& prog_builder = world.GetProgramBuilder();
38+
39+
auto& org = world.GetOrg(0);
40+
auto& sgp_host = static_cast<sgp_host_t&>(org);
41+
hardware_t& hw = sgp_host.GetHardware();
42+
43+
std::ostringstream output;
44+
45+
WHEN("Program contains Nop Instruction"){
46+
program_t program;
47+
prog_builder.AddStartAnchor(program);
48+
prog_builder.AddInst(program, "Nop-0", 0);
49+
hw.Reset();
50+
hw.SetProgram(program);
51+
52+
hw.PrintCode(output);
53+
54+
THEN("Global Anchor and Nop Instruction should be printed"){
55+
REQUIRE(output.str() == "AA:\n nop-0 \n");
56+
}
57+
}
58+
WHEN("Program contains Increment Instruction"){
59+
program_t program;
60+
prog_builder.AddStartAnchor(program);
61+
prog_builder.AddInst(program, "Increment", 0);
62+
hw.Reset();
63+
hw.SetProgram(program);
64+
65+
hw.PrintCode(output);
66+
67+
THEN("Global Anchor and Increment Instruction should be printed"){
68+
REQUIRE(output.str() == "AA:\n increment r0\n");
69+
}
70+
}
71+
WHEN("Program contains Decrement Instruction"){
72+
program_t program;
73+
prog_builder.AddStartAnchor(program);
74+
prog_builder.AddInst(program, "Decrement", 0);
75+
hw.Reset();
76+
hw.SetProgram(program);
77+
78+
hw.PrintCode(output);
79+
80+
THEN("Global Anchor and Increment Instruction should be printed"){
81+
REQUIRE(output.str() == "AA:\n decrement r0\n");
82+
}
83+
}
84+
85+
WHEN("Program contains Nand Instruction"){
86+
program_t program;
87+
prog_builder.AddStartAnchor(program);
88+
prog_builder.AddInst(program, "Nand", 0, 1, 0);
89+
hw.Reset();
90+
hw.SetProgram(program);
91+
92+
hw.PrintCode(output);
93+
94+
THEN("Global Anchor and Nand Instruction should be printed"){
95+
REQUIRE(output.str() == "AA:\n nand r0, r1, r0\n");
96+
}
97+
}
98+
}
99+
100+
TEST_CASE("Test Printing Complex Instructions", "[sgp]"){
101+
using world_t = sgpmode::SGPWorld;
102+
using cpu_state_t = sgpmode::CPUState<world_t>;
103+
using hw_spec_t = sgpmode::SGPHardwareSpec<sgpmode::Library, cpu_state_t, world_t>;
104+
using hardware_t = sgpmode::SGPHardware<hw_spec_t>;
105+
using program_t = typename world_t::sgp_prog_t;
106+
using sgp_host_t = sgpmode::SGPHost<hw_spec_t>;
107+
using tag_t = typename hw_spec_t::tag_t;
108+
109+
sgpmode::SymConfigSGP config;
110+
config.CYCLES_PER_UPDATE(0);
111+
config.HOST_REPRO_RES(1);
112+
config.SEED(61);
113+
config.TASK_ENV_CFG_PATH("source/test/sgp_mode_test/hardware-test-env.json");
114+
config.FILE_PATH("hardware_test_output");
115+
config.POP_SIZE(1);
116+
config.START_MOI(0);
117+
config.TASK_IO_UNIQUE_OUTPUT(true);
118+
119+
emp::Random random(config.SEED());
120+
world_t world(random, &config);
121+
world.Setup();
122+
auto& prog_builder = world.GetProgramBuilder();
123+
124+
auto& org = world.GetOrg(0);
125+
auto& sgp_host = static_cast<sgp_host_t&>(org);
126+
hardware_t& hw = sgp_host.GetHardware();
127+
128+
std::ostringstream output;
129+
130+
WHEN("Program contains JumpIfNEq Instruction"){
131+
program_t program;
132+
tag_t start_tag(prog_builder.GetStartTag());
133+
tag_t tag1("0000000000000000000000000000000000000000000000000000000000000001");
134+
135+
prog_builder.AddStartAnchor(program);
136+
prog_builder.AddInst(program, "Nop-0", 0);
137+
prog_builder.AddInst(program, "Nop-0", 0);
138+
prog_builder.AddInst(program, "Nop-0", 0);
139+
prog_builder.AddInst(program, "Global Anchor", tag1);
140+
prog_builder.AddInst(program, "Nop-0", 0);
141+
prog_builder.AddInst(program, "Nop-0", 0);
142+
prog_builder.AddInst(program, "JumpIfNEq", 0, 1, 0, tag1);
143+
hw.Reset();
144+
hw.SetProgram(program);
145+
146+
hw.PrintCode(output);
147+
148+
THEN("Global Anchor and Nop Instruction should be printed"){
149+
REQUIRE(output.str() == "AA:\n nop-0 \n nop-0 \n nop-0 \nAB:\n nop-0 \n nop-0 \n jumpifneq r0, r1, AB\n");
150+
}
151+
}
152+
153+
WHEN("Program contains JumpIfEq Instruction"){
154+
program_t program;
155+
tag_t start_tag(prog_builder.GetStartTag());
156+
tag_t tag1("0000000000000000000000000000000000000000000000000000000000000001");
157+
158+
prog_builder.AddStartAnchor(program);
159+
prog_builder.AddInst(program, "Nop-0", 0);
160+
prog_builder.AddInst(program, "Nop-0", 0);
161+
prog_builder.AddInst(program, "Nop-0", 0);
162+
prog_builder.AddInst(program, "Global Anchor", tag1);
163+
prog_builder.AddInst(program, "Nop-0", 0);
164+
prog_builder.AddInst(program, "Nop-0", 0);
165+
prog_builder.AddInst(program, "JumpIfEq", 0, 1, 0, tag1);
166+
hw.Reset();
167+
hw.SetProgram(program);
168+
169+
hw.PrintCode(output);
170+
171+
THEN("Global Anchor and Nop Instruction should be printed"){
172+
REQUIRE(output.str() == "AA:\n nop-0 \n nop-0 \n nop-0 \nAB:\n nop-0 \n nop-0 \n jumpifeq r0, r1, AB\n");
173+
}
174+
}
175+
176+
WHEN("Program contains JumpIfLess Instruction"){
177+
program_t program;
178+
tag_t start_tag(prog_builder.GetStartTag());
179+
tag_t tag1("0000000000000000000000000000000000000000000000000000000000000010");
180+
181+
prog_builder.AddStartAnchor(program);
182+
prog_builder.AddInst(program, "Nop-0", 0);
183+
prog_builder.AddInst(program, "Nop-0", 0);
184+
prog_builder.AddInst(program, "Nop-0", 0);
185+
prog_builder.AddInst(program, "Global Anchor", tag1);
186+
prog_builder.AddInst(program, "Nop-0", 0);
187+
prog_builder.AddInst(program, "Nop-0", 0);
188+
prog_builder.AddInst(program, "JumpIfLess", 0, 1, 0, tag1);
189+
hw.Reset();
190+
hw.SetProgram(program);
191+
192+
hw.PrintCode(output);
193+
194+
THEN("Global Anchor and Nop Instruction should be printed"){
195+
REQUIRE(output.str() == "AA:\n nop-0 \n nop-0 \n nop-0 \nAB:\n nop-0 \n nop-0 \n jumpifless r0, r1, AB\n");
196+
}
197+
}
198+
199+
}

0 commit comments

Comments
 (0)