Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
bitwise_trace.test.cpp
Go to the documentation of this file.
1#include <gmock/gmock.h>
2#include <gtest/gtest.h>
3
4#include <cstdint>
5
6#include "barretenberg/vm2/common/memory_types.hpp"
7#include "barretenberg/vm2/testing/macros.hpp"
8#include "barretenberg/vm2/tracegen/bitwise_trace.hpp"
9#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
10
11namespace bb::avm2::tracegen {
12namespace {
13
14using testing::ElementsAre;
15
16TEST(BitwiseTraceGenTest, U1And)
17{
18 TestTraceContainer trace;
19 BitwiseTraceBuilder builder;
20
21 builder.process(
22 {
23 {
24 .operation = BitwiseOperation::AND,
25 .a = MemoryValue::from(uint1_t(0)),
26 .b = MemoryValue::from(uint1_t(1)),
27 .res = 0,
28 },
29 },
30 trace);
31
32 EXPECT_EQ(trace.as_rows().size(), 2);
33
34 EXPECT_THAT(trace.as_rows(),
35 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
36 ROW_FIELD_EQ(bitwise_acc_ia, 0),
37 ROW_FIELD_EQ(bitwise_acc_ib, 0),
38 ROW_FIELD_EQ(bitwise_acc_ic, 0),
39 ROW_FIELD_EQ(bitwise_ia_byte, 0),
40 ROW_FIELD_EQ(bitwise_ib_byte, 0),
41 ROW_FIELD_EQ(bitwise_ic_byte, 0),
42 ROW_FIELD_EQ(bitwise_ctr, 0),
43 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
44 ROW_FIELD_EQ(bitwise_end, 0),
45 ROW_FIELD_EQ(bitwise_sel, 0),
46 ROW_FIELD_EQ(bitwise_start, 0)),
47 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
48 ROW_FIELD_EQ(bitwise_acc_ia, 0),
49 ROW_FIELD_EQ(bitwise_acc_ib, 1),
50 ROW_FIELD_EQ(bitwise_acc_ic, 0),
51 ROW_FIELD_EQ(bitwise_ia_byte, 0),
52 ROW_FIELD_EQ(bitwise_ib_byte, 1),
53 ROW_FIELD_EQ(bitwise_ic_byte, 0),
54 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U1)),
55 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U1)),
56 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::U1)),
57 ROW_FIELD_EQ(bitwise_ctr, 1),
58 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
59 ROW_FIELD_EQ(bitwise_end, 1),
60 ROW_FIELD_EQ(bitwise_sel, 1),
61 ROW_FIELD_EQ(bitwise_sel_compute, 1),
62 ROW_FIELD_EQ(bitwise_sel_get_ctr, 1),
63 ROW_FIELD_EQ(bitwise_start, 1))));
64}
65
66TEST(BitwiseTraceGenTest, U32And)
67{
68 TestTraceContainer trace;
69 BitwiseTraceBuilder builder;
70
71 builder.process(
72 {
73 {
74 .operation = BitwiseOperation::AND,
75 .a = MemoryValue::from<uint32_t>(0x52488425),
76 .b = MemoryValue::from<uint32_t>(0xC684486C),
77 .res = 0x42000024,
78 },
79 },
80 trace);
81
82 EXPECT_EQ(trace.as_rows().size(), 5);
83
84 EXPECT_THAT(trace.as_rows(),
85 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
86 ROW_FIELD_EQ(bitwise_acc_ia, 0),
87 ROW_FIELD_EQ(bitwise_acc_ib, 0),
88 ROW_FIELD_EQ(bitwise_acc_ic, 0),
89 ROW_FIELD_EQ(bitwise_ia_byte, 0),
90 ROW_FIELD_EQ(bitwise_ib_byte, 0),
91 ROW_FIELD_EQ(bitwise_ic_byte, 0),
92 ROW_FIELD_EQ(bitwise_ctr, 0),
93 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
94 ROW_FIELD_EQ(bitwise_end, 0),
95 ROW_FIELD_EQ(bitwise_sel, 0),
96 ROW_FIELD_EQ(bitwise_start, 0)),
97 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
98 ROW_FIELD_EQ(bitwise_acc_ia, 0x52488425),
99 ROW_FIELD_EQ(bitwise_acc_ib, 0xC684486C),
100 ROW_FIELD_EQ(bitwise_acc_ic, 0x42000024),
101 ROW_FIELD_EQ(bitwise_ia_byte, 0x25),
102 ROW_FIELD_EQ(bitwise_ib_byte, 0x6C),
103 ROW_FIELD_EQ(bitwise_ic_byte, 0x24),
104 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U32)),
105 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U32)),
106 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::U32)),
107 ROW_FIELD_EQ(bitwise_ctr, 4),
108 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, FF(3).invert()),
109 ROW_FIELD_EQ(bitwise_end, 0),
110 ROW_FIELD_EQ(bitwise_sel, 1),
111 ROW_FIELD_EQ(bitwise_sel_compute, 1),
112 ROW_FIELD_EQ(bitwise_sel_get_ctr, 1),
113 ROW_FIELD_EQ(bitwise_start, 1)),
114 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
115 ROW_FIELD_EQ(bitwise_acc_ia, 0x524884),
116 ROW_FIELD_EQ(bitwise_acc_ib, 0xC68448),
117 ROW_FIELD_EQ(bitwise_acc_ic, 0x420000),
118 ROW_FIELD_EQ(bitwise_ia_byte, 0x84),
119 ROW_FIELD_EQ(bitwise_ib_byte, 0x48),
120 ROW_FIELD_EQ(bitwise_ic_byte, 0x00),
121 ROW_FIELD_EQ(bitwise_tag_a, 0),
122 ROW_FIELD_EQ(bitwise_tag_b, 0),
123 ROW_FIELD_EQ(bitwise_tag_c, 0),
124 ROW_FIELD_EQ(bitwise_ctr, 3),
125 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, FF(2).invert()),
126 ROW_FIELD_EQ(bitwise_end, 0),
127 ROW_FIELD_EQ(bitwise_sel, 1),
128 ROW_FIELD_EQ(bitwise_sel_compute, 1),
129 ROW_FIELD_EQ(bitwise_start, 0)),
130 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
131 ROW_FIELD_EQ(bitwise_acc_ia, 0x5248),
132 ROW_FIELD_EQ(bitwise_acc_ib, 0xC684),
133 ROW_FIELD_EQ(bitwise_acc_ic, 0x4200),
134 ROW_FIELD_EQ(bitwise_ia_byte, 0x48),
135 ROW_FIELD_EQ(bitwise_ib_byte, 0x84),
136 ROW_FIELD_EQ(bitwise_ic_byte, 0x00),
137 ROW_FIELD_EQ(bitwise_tag_a, 0),
138 ROW_FIELD_EQ(bitwise_tag_b, 0),
139 ROW_FIELD_EQ(bitwise_tag_c, 0),
140 ROW_FIELD_EQ(bitwise_ctr, 2),
141 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 1),
142 ROW_FIELD_EQ(bitwise_end, 0),
143 ROW_FIELD_EQ(bitwise_sel, 1),
144 ROW_FIELD_EQ(bitwise_sel_compute, 1),
145 ROW_FIELD_EQ(bitwise_start, 0)),
146 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
147 ROW_FIELD_EQ(bitwise_acc_ia, 0x52),
148 ROW_FIELD_EQ(bitwise_acc_ib, 0xC6),
149 ROW_FIELD_EQ(bitwise_acc_ic, 0x42),
150 ROW_FIELD_EQ(bitwise_ia_byte, 0x52),
151 ROW_FIELD_EQ(bitwise_ib_byte, 0xC6),
152 ROW_FIELD_EQ(bitwise_ic_byte, 0x42),
153 ROW_FIELD_EQ(bitwise_tag_a, 0),
154 ROW_FIELD_EQ(bitwise_tag_b, 0),
155 ROW_FIELD_EQ(bitwise_tag_c, 0),
156 ROW_FIELD_EQ(bitwise_ctr, 1),
157 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
158 ROW_FIELD_EQ(bitwise_end, 1),
159 ROW_FIELD_EQ(bitwise_sel, 1),
160 ROW_FIELD_EQ(bitwise_sel_compute, 1),
161 ROW_FIELD_EQ(bitwise_start, 0))));
162}
163
164TEST(BitwiseTraceGenTest, ErrorInputFF)
165{
166 TestTraceContainer trace;
167 BitwiseTraceBuilder builder;
168
169 std::vector<simulation::BitwiseEvent> events = {
170 { .operation = BitwiseOperation::AND,
171 .a = MemoryValue::from_tag(MemoryTag::FF, 1),
172 .b = MemoryValue::from_tag(MemoryTag::FF, 1),
173 .res = 0 },
174 };
175 builder.process(events, trace);
176
177 EXPECT_THAT(trace.as_rows(),
178 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
179 ROW_FIELD_EQ(bitwise_acc_ia, 0),
180 ROW_FIELD_EQ(bitwise_acc_ib, 0),
181 ROW_FIELD_EQ(bitwise_acc_ic, 0),
182 ROW_FIELD_EQ(bitwise_ia_byte, 0),
183 ROW_FIELD_EQ(bitwise_ib_byte, 0),
184 ROW_FIELD_EQ(bitwise_ic_byte, 0),
185 ROW_FIELD_EQ(bitwise_ctr, 0),
186 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
187 ROW_FIELD_EQ(bitwise_end, 0),
188 ROW_FIELD_EQ(bitwise_sel, 0)),
189 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
190 ROW_FIELD_EQ(bitwise_sel, 1),
191 ROW_FIELD_EQ(bitwise_acc_ia, 1),
192 ROW_FIELD_EQ(bitwise_acc_ib, 1),
193 ROW_FIELD_EQ(bitwise_acc_ic, 0),
194 ROW_FIELD_EQ(bitwise_ia_byte, 1),
195 ROW_FIELD_EQ(bitwise_ib_byte, 1),
196 ROW_FIELD_EQ(bitwise_ic_byte, 0),
197 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::FF)),
198 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::FF)),
199 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::FF)),
200 ROW_FIELD_EQ(bitwise_ctr, 0),
201 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
202 ROW_FIELD_EQ(bitwise_end, 1),
203 // Err Flags
204 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 1),
205 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 0),
206 ROW_FIELD_EQ(bitwise_err, 1),
207 ROW_FIELD_EQ(bitwise_tag_a_inv, 0))));
208}
209
210TEST(BitwiseTraceGenTest, ErrorTagMismatch)
211{
212 TestTraceContainer trace;
213 BitwiseTraceBuilder builder;
214
215 std::vector<simulation::BitwiseEvent> events = {
216 { .operation = BitwiseOperation::AND,
217 .a = MemoryValue::from_tag(MemoryTag::U8, 1),
218 .b = MemoryValue::from_tag(MemoryTag::U16, 1),
219 .res = 0 },
220 };
221 builder.process(events, trace);
222
223 EXPECT_THAT(
224 trace.as_rows(),
225 ElementsAre(
226 AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
227 ROW_FIELD_EQ(bitwise_acc_ia, 0),
228 ROW_FIELD_EQ(bitwise_acc_ib, 0),
229 ROW_FIELD_EQ(bitwise_acc_ic, 0),
230 ROW_FIELD_EQ(bitwise_ia_byte, 0),
231 ROW_FIELD_EQ(bitwise_ib_byte, 0),
232 ROW_FIELD_EQ(bitwise_ic_byte, 0),
233 ROW_FIELD_EQ(bitwise_ctr, 0),
234 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
235 ROW_FIELD_EQ(bitwise_end, 0),
236 ROW_FIELD_EQ(bitwise_sel, 0)),
237 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
238 ROW_FIELD_EQ(bitwise_sel, 1),
239 ROW_FIELD_EQ(bitwise_acc_ia, 1),
240 ROW_FIELD_EQ(bitwise_acc_ib, 1),
241 ROW_FIELD_EQ(bitwise_acc_ic, 0),
242 ROW_FIELD_EQ(bitwise_ia_byte, 1),
243 ROW_FIELD_EQ(bitwise_ib_byte, 1),
244 ROW_FIELD_EQ(bitwise_ic_byte, 0),
245 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U8)),
246 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U16)),
247 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::FF)),
248 ROW_FIELD_EQ(bitwise_ctr, 0),
249 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
250 ROW_FIELD_EQ(bitwise_end, 1),
251 // Err Flags
252 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 0),
253 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 1),
254 ROW_FIELD_EQ(bitwise_err, 1),
255 ROW_FIELD_EQ(
256 bitwise_tag_ab_diff_inv,
257 FF(static_cast<uint8_t>(MemoryTag::U8) - static_cast<uint8_t>(MemoryTag::U16)).invert()))));
258}
259
260TEST(BitwiseTraceGenTest, ErrorFFAndTagMismatch)
261{
262 TestTraceContainer trace;
263 BitwiseTraceBuilder builder;
264
265 std::vector<simulation::BitwiseEvent> events = {
266 { .operation = BitwiseOperation::AND,
267 .a = MemoryValue::from_tag(MemoryTag::FF, 1),
268 .b = MemoryValue::from_tag(MemoryTag::U16, 1),
269 .res = 0 },
270 };
271 builder.process(events, trace);
272
273 EXPECT_THAT(
274 trace.as_rows(),
275 ElementsAre(
276 AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
277 ROW_FIELD_EQ(bitwise_acc_ia, 0),
278 ROW_FIELD_EQ(bitwise_acc_ib, 0),
279 ROW_FIELD_EQ(bitwise_acc_ic, 0),
280 ROW_FIELD_EQ(bitwise_ia_byte, 0),
281 ROW_FIELD_EQ(bitwise_ib_byte, 0),
282 ROW_FIELD_EQ(bitwise_ic_byte, 0),
283 ROW_FIELD_EQ(bitwise_ctr, 0),
284 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
285 ROW_FIELD_EQ(bitwise_end, 0),
286 ROW_FIELD_EQ(bitwise_sel, 0)),
287 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
288 ROW_FIELD_EQ(bitwise_sel, 1),
289 ROW_FIELD_EQ(bitwise_acc_ia, 1),
290 ROW_FIELD_EQ(bitwise_acc_ib, 1),
291 ROW_FIELD_EQ(bitwise_acc_ic, 0),
292 ROW_FIELD_EQ(bitwise_ia_byte, 1),
293 ROW_FIELD_EQ(bitwise_ib_byte, 1),
294 ROW_FIELD_EQ(bitwise_ic_byte, 0),
295 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::FF)),
296 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U16)),
297 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::FF)),
298 ROW_FIELD_EQ(bitwise_ctr, 0),
299 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
300 ROW_FIELD_EQ(bitwise_end, 1),
301 // Err Flags
302 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 1),
303 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 1),
304 ROW_FIELD_EQ(bitwise_err, 1),
305 ROW_FIELD_EQ(bitwise_tag_a_inv, 0),
306 ROW_FIELD_EQ(
307 bitwise_tag_ab_diff_inv,
308 (FF(static_cast<uint8_t>(MemoryTag::FF)) - FF(static_cast<uint8_t>(MemoryTag::U16))).invert()))));
309}
310
311} // namespace
312} // namespace bb::avm2::tracegen
bitwise_trace.hpp
bb::avm2::TaggedValue::from
static TaggedValue from(T value)
Definition tagged_value.hpp:126
bb::avm2::TaggedValue::from_tag
static TaggedValue from_tag(ValueTag tag, FF value)
Definition tagged_value.cpp:227
bb::avm2::tracegen::AluTraceBuilder::process
void process(const simulation::EventEmitterInterface< simulation::AluEvent >::Container &events, TraceContainer &trace)
Process the ALU events and populate the ALU relevant columns in the trace.
Definition alu_trace.cpp:410
bb::avm2::tracegen::TestTraceContainer::as_rows
std::vector< AvmFullRowConstRef > as_rows() const
Definition test_trace_container.cpp:28
builder
AluTraceBuilder builder
Definition alu.test.cpp:124
trace
TestTraceContainer trace
Definition data_copy.test.cpp:63
ROW_FIELD_EQ
#define ROW_FIELD_EQ(field_name, expression)
Definition macros.hpp:7
memory_types.hpp
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
bb::TEST
TEST(BoomerangMegaCircuitBuilder, BasicCircuit)
Definition graph_description_megacircuitbuilder.test.cpp:22
std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13
test_trace_container.hpp