ryan/libdpf
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libdpf/test/tests/compose_test.cpp
Ryan Henry 0d22946a0e Checkpoint the party/runtime stack before share-program and malicious-mode work. 
Ship the TLS mesh, composer, Beaver/Yao/leaf MPC, prep/online paths, apps, and docs so the tree is pushable before elevating share_expr, security_mode, and prep resume.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-28 05:59:19 -06:00

1899 lines
64 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include <gtest/gtest.h>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <map>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <thread>
#include <tuple>
#include <vector>
#include "dpf/beaver.hpp"
#include "dpf/compose.hpp"
#include "dpf/iknp.hpp"
#include "dpf/app_flow.hpp"
#include "dpf/app_plans.hpp"
#include "dpf/experiment.hpp"
#include "dpf/iknp_graphs.hpp"
#include "dpf/mesh_apps.hpp"
#include "dpf/net/edge_mesh.hpp"
#include "dpf/net/memory_sink.hpp"
#include "dpf/net/sink_exchange.hpp"
#include "dpf/pad_graphs.hpp"
#include "dpf/prg_aes.hpp"
#include "dpf/random.hpp"
#include "dpf/session_host.hpp"
namespace
{
using dpf::protocol::composer;
using dpf::protocol::domain;
using dpf::protocol::effect;
using dpf::protocol::kernel_fn;
using dpf::protocol::node;
namespace opcodes = dpf::protocol::opcodes;
using dpf::protocol::op_flags;
using dpf::net::make_memory_sink_pair;
TEST(Compose, SharedBlindInterned)
{
composer c(0);
auto x = c.input(domain::a, 8);
int blind_calls = 0;
auto b0 = c.blind(x, 42);
auto b1 = c.blind(x, 42);
EXPECT_EQ(b0, b1);
auto p = c.schedule();
EXPECT_EQ(p.effect_count(effect::blind), 1u);
std::map<std::uint32_t, kernel_fn> kernels;
kernels[42] = [&](std::uint32_t, const std::vector<node> & nodes,
const std::vector<dpf::protocol::block_span> &,
dpf::protocol::block_span out, std::size_t) {
++blind_calls;
for (std::size_t i = 0; i < out.lanes; ++i)
{
std::uint64_t v = 0x1111;
std::memcpy(out.at(i), &v, 8);
}
EXPECT_EQ(nodes.size(), 1u);
};
auto [sink0, sink1] = make_memory_sink_pair(1, p.slot_bytes_all());
(void)sink1;
std::vector<std::vector<std::uint8_t>> values;
values.resize(c.node_count());
values[x.id].resize(8);
std::uint64_t xv = 7;
std::memcpy(values[x.id].data(), &xv, 8);
dpf::protocol::drive(p, sink0, values, kernels, 0);
EXPECT_EQ(blind_calls, 1);
std::uint64_t got = 0;
std::memcpy(&got, values[b0.id].data(), 8);
EXPECT_EQ(got, 0x1111u);
}
TEST(Compose, LevelWalkSharesExpands)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto a = c.fss_point(seed, 2, 16);
const auto shared = c.schedule().effect_count(effect::expand);
// depth 2: one fused L||R expand per level (hand DPF PRG stretch).
EXPECT_EQ(shared, 2u);
auto b = c.fss_point(seed, 2, 16);
EXPECT_EQ(c.schedule().effect_count(effect::expand), shared);
auto other = c.input(domain::fss, 16);
auto d = c.fss_cmp(other, 2, 16);
EXPECT_EQ(c.schedule().effect_count(effect::expand), shared * 2);
EXPECT_EQ(c.domain_of(a), domain::b);
EXPECT_EQ(c.domain_of(b), domain::b);
EXPECT_EQ(c.domain_of(d), domain::a);
}
TEST(Compose, ExchangeWaves)
{
composer c(0);
auto x = c.input(domain::a, 8);
auto e0 = c.exchange(x);
auto e1 = c.exchange(c.compute(opcodes::user_base + 10, {e0}, domain::a, 8));
auto e2 = c.exchange(c.compute(opcodes::user_base + 10, {e1}, domain::a, 8));
(void)e2;
auto p = c.schedule();
EXPECT_EQ(p.rounds(), 3u);
composer c2(0);
auto a = c2.input(domain::a, 8);
auto b = c2.input(domain::a, 8);
auto o0 = c2.exchange(a);
auto o1 = c2.exchange(b);
(void)o0;
(void)o1;
auto p2 = c2.schedule();
EXPECT_EQ(p2.rounds(), 1u);
}
TEST(Compose, ExchangeReconstructsOnMemorySink)
{
composer c0(0);
composer c1(1);
auto x0 = c0.input(domain::a, 8);
auto x1 = c1.input(domain::a, 8);
auto e0 = c0.exchange(x0);
auto e1 = c1.exchange(x1);
(void)e0;
(void)e1;
auto p0 = c0.schedule();
auto p1 = c1.schedule();
ASSERT_EQ(p0.rounds(), 1u);
ASSERT_EQ(p1.rounds(), 1u);
auto [sink0, sink1] = make_memory_sink_pair(1, p0.slot_bytes_all());
std::uint64_t a = 3, b = 5;
sink0.submit(0, 0, reinterpret_cast<const std::uint8_t *>(&a), 8);
sink1.submit(0, 0, reinterpret_cast<const std::uint8_t *>(&b), 8);
sink0.flush();
ASSERT_TRUE(sink0.peer_ready(0, 0));
ASSERT_TRUE(sink1.peer_ready(0, 0));
std::uint64_t peer0 = 0, peer1 = 0;
sink0.read_peer(0, 0, reinterpret_cast<std::uint8_t *>(&peer0), 8);
sink1.read_peer(0, 0, reinterpret_cast<std::uint8_t *>(&peer1), 8);
EXPECT_EQ(a + peer0, 8u);
EXPECT_EQ(b + peer1, 8u);
}
TEST(Compose, CommutativeComputeInterned)
{
composer c(0);
auto x = c.input(domain::a, 8);
auto y = c.input(domain::a, 8);
auto p0 = c.compute(99, {x, y}, domain::a, 8, op_flags::commutative);
auto p1 = c.compute(99, {y, x}, domain::a, 8, op_flags::commutative);
EXPECT_EQ(p0, p1);
}
TEST(Compose, SimdGroupOneKernelCall)
{
composer c(0);
auto nodes = c.fan(8, [&](std::size_t) {
return c.input(domain::a, 8);
});
std::vector<node> outs;
for (auto n : nodes)
outs.push_back(c.compute(77, {n}, domain::a, 8));
auto p = c.schedule();
int calls = 0;
std::size_t total_nodes = 0;
std::map<std::uint32_t, kernel_fn> kernels;
kernels[77] = [&](std::uint32_t, const std::vector<node> & ns,
const std::vector<dpf::protocol::block_span> & ins,
dpf::protocol::block_span out, std::size_t sink_lanes) {
++calls;
total_nodes += ns.size();
EXPECT_EQ(ns.size(), 8u);
EXPECT_EQ(out.lanes, 8u * sink_lanes);
EXPECT_EQ(ins.size(), 1u);
for (std::size_t i = 0; i < out.lanes; ++i)
std::memset(out.at(i), 1, 8);
};
auto slots = p.slot_bytes_all();
if (slots.empty())
slots.push_back(0);
auto [sink0, sink1] = make_memory_sink_pair(1, std::move(slots));
(void)sink1;
std::vector<std::vector<std::uint8_t>> values(c.node_count());
for (auto n : nodes)
values[n.id].assign(8, 0);
dpf::protocol::drive(p, sink0, values, kernels, 0);
EXPECT_EQ(calls, 1);
EXPECT_EQ(total_nodes, 8u);
ASSERT_GE(p.waves(), 1u);
std::size_t grouped = 0;
for (const auto & g : p.wave(0).groups)
{
if (g.opcode == 77)
grouped += g.nodes.size();
}
EXPECT_EQ(grouped, 8u);
(void)outs;
}
TEST(Compose, DomainConversionInternedAndRejected)
{
composer c(0);
auto leaf = c.input(domain::b, 8);
auto a0 = c.as(leaf, domain::a);
auto a1 = c.as(leaf, domain::a);
EXPECT_EQ(a0, a1);
auto p = c.schedule();
EXPECT_EQ(p.conversion_count(domain::b, domain::a), 1u);
EXPECT_THROW(c.as(leaf, domain::rss), std::invalid_argument);
// Inverse fold
auto back = c.as(a0, domain::b);
EXPECT_EQ(back, leaf);
}
TEST(Compose, RssProductInterned)
{
composer c(0);
auto x = c.input(domain::rss, 16);
auto y = c.input(domain::rss, 16);
auto f0 = c.rss_product(x, y);
auto f1 = c.rss_product(y, x); // commutative
EXPECT_EQ(f0, f1);
EXPECT_EQ(c.domain_of(f0), domain::y);
auto own = c.input(domain::y, 8);
auto next = c.input(domain::y, 8);
auto r = c.y2rss(own, next);
EXPECT_EQ(c.domain_of(r), domain::rss);
}
TEST(Compose, AbyProductSharesBlind)
{
composer c(0);
auto & s = c.aby<std::uint64_t>();
auto x = s.input();
auto y = s.input();
auto z = s.input();
auto xy = s.product(x, y);
auto xz = s.product(x, z);
(void)xy;
(void)xz;
// One blind for x across both products.
s.sample();
EXPECT_EQ(s.round_of(xy), s.round_of(xz));
// opened wires create barrier exchanges on the composer
auto nxy = c.opened<std::uint64_t>(xy);
auto nxz = c.opened<std::uint64_t>(xz);
EXPECT_EQ(c.domain_of(nxy), domain::a);
EXPECT_EQ(c.domain_of(nxz), domain::a);
auto barriers = s.exchange_barriers();
EXPECT_FALSE(barriers.empty());
}
// Practical gap (SUBLEQ scale / Grotto η): opening a product must schedule
// every prior δ flush, not only the product's barrier.
TEST(Compose, BeaverBarrierChainMaterializesPriors)
{
composer c(0);
auto & s = c.aby<std::uint64_t>();
auto x = s.input();
auto y = s.input();
auto z = s.product(x, y);
// Nested use so z is δ-opened in a later barrier (hand SUBLEQ scale path).
auto w = s.product(z, x);
(void)w;
s.sample();
const auto barriers = s.exchange_barriers();
ASSERT_GE(barriers.size(), 2u);
auto nz = c.opened<std::uint64_t>(z);
(void)nz;
// Opening z must pull in every prior flush (factor open), not only z's.
std::size_t beaver_ex = 0;
for (std::uint32_t id = 0; id < c.node_count(); ++id)
{
if (c.effect_of(node{id}) != effect::exchange)
continue;
// Beaver barrier opcodes are beaver_delta + index.
++beaver_ex;
}
// FSS-free composer: every exchange is a beaver barrier.
EXPECT_GE(beaver_ex, 2u);
}
// Practical gap (Duoram / PIR + Beaver): beaver waves must not hitch onto
// unrelated FSS exchange node ids (old fake inputs = {sess, barrier_index}).
TEST(Compose, BeaverBarrierWavesIndependentOfFssNodeIds)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto leaf = c.fss_point(seed, 3, 16);
(void)leaf;
const auto fss_only = c.schedule();
// depth d → d exchange waves + final consumer wave.
EXPECT_EQ(fss_only.effect_count(effect::exchange), 3u);
EXPECT_EQ(fss_only.rounds(), 3u); // == exchange_waves
EXPECT_EQ(fss_only.exchange_waves(), 3u);
auto & s = c.aby<std::uint64_t>();
auto x = s.input();
auto y = s.input();
auto z = s.product(x, y);
s.sample();
auto nz = c.opened<std::uint64_t>(z);
(void)nz;
auto p = c.schedule();
// Independent beaver opens add exchange nodes; they must not disappear
// or be ordered solely by colliding with FSS node ids.
EXPECT_GT(p.effect_count(effect::exchange), 3u);
}
// Practical gap (grotto_signum_lut): N comparison walks share expands when
// seeded alike; packed same-depth opens are one wave per level.
TEST(Compose, GrottoShapedFanSharesSeedExpands)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
constexpr std::size_t n = 7;
auto leaves = c.fan(n, [&](std::size_t) {
return c.fss_cmp(seed, 4, 16);
});
EXPECT_EQ(leaves.size(), n);
auto p = c.schedule();
// One fused expand per level for the shared seed, not n×depth.
EXPECT_EQ(p.effect_count(effect::expand), 4u);
EXPECT_EQ(p.effect_count(effect::exchange), 4u);
EXPECT_EQ(p.rounds(), 4u); // == exchange_waves (no empty sink round)
}
// Latency objective: keep sign×linear in one round (Pika / online Grotto).
// Prep objective (default) still peels for Appendix-E savings.
TEST(Compose, AbySessionUsesRoundAwareSchedule)
{
composer c(0);
auto & s = c.aby<std::uint64_t>();
EXPECT_EQ(s.get_schedule_objective(),
dpf::beavers::schedule_objective::rounds);
auto sgn = s.input();
auto x = s.input();
auto a0 = s.input();
auto a1 = s.input();
auto lin = s(sgn * (a1 * x + a0));
EXPECT_EQ(s.round_of(lin), 1);
dpf::beavers::session<std::uint64_t> prep;
prep.set_schedule_objective(dpf::beavers::schedule_objective::prep);
auto ps = prep.input();
auto px = prep.input();
auto pa0 = prep.input();
auto pa1 = prep.input();
auto plin = prep(ps * (pa1 * px + pa0));
EXPECT_EQ(prep.round_of(plin), 2);
EXPECT_LT(prep.preprocessing_count(), s.preprocessing_count());
}
// Express/Sabre: sketch rides in the last CW flush — no extra exchange round.
TEST(Compose, ExpressShapedSketchFusedIntoLastCw)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto sketch = c.input(domain::a, 8);
// Naive: walk, then a sketch exchange that depends on the leaf.
auto leaf = c.fss_point(seed, 4, 16);
auto sk_dep = c.compute(opcodes::user_base + 50, {leaf, sketch},
domain::a, 8);
auto sk_ex = c.exchange(sk_dep);
(void)sk_ex;
auto naive_plan = c.schedule();
composer c2(0);
auto seed2 = c2.input(domain::fss, 16);
auto sketch2 = c2.input(domain::a, 8);
auto wr = c2.fss_point_fused(seed2, 4, 16, sketch2);
auto fused_plan = c2.schedule();
EXPECT_EQ(c2.domain_of(wr.leaf), domain::b);
EXPECT_EQ(c2.domain_of(wr.trailer_open), domain::a);
EXPECT_EQ(naive_plan.effect_count(effect::exchange), 5u);
EXPECT_EQ(fused_plan.effect_count(effect::exchange), 4u);
// Same leaf-wave depth, but naive pays a fifth exchange-bearing wave.
EXPECT_EQ(fused_plan.rounds(), 4u);
EXPECT_EQ(naive_plan.exchange_waves(), 5u);
EXPECT_EQ(fused_plan.exchange_waves(), 4u);
// Last CW slot carries step‖trailer.
const auto & last_wave = fused_plan.wave(3);
ASSERT_FALSE(last_wave.exchanges.empty());
EXPECT_EQ(fused_plan.value_bytes_of(last_wave.exchanges[0].id), 16u + 8u);
EXPECT_TRUE(fused_plan.wave(4).exchanges.empty());
}
TEST(Compose, BeaverExchangeBarriersMatchBatch)
{
dpf::beavers::session<std::uint64_t> s;
auto x = s.input();
auto y = s.input();
auto z = s.product(x, y);
(void)z;
s.sample();
auto barriers = s.exchange_barriers();
EXPECT_GE(barriers.size(), 1u);
// Party path: stepper completes with same number of barriers.
dpf::beavers::session<std::uint64_t> s0;
dpf::beavers::session<std::uint64_t> s1;
auto x0 = s0.input();
auto y0 = s0.input();
auto z0 = s0.product(x0, y0);
auto x1 = s1.input();
auto y1 = s1.input();
auto z1 = s1.product(x1, y1);
(void)z0;
(void)z1;
s0.sample();
// copy tape
auto tape = s0.export_party(0);
// Use install after sampling on dealer session - parties need tapes.
// Simpler: evaluate_party_batch with matching exchange count.
dpf::beavers::session<std::uint64_t> dealer;
auto dx = dealer.input();
auto dy = dealer.input();
auto dz = dealer.product(dx, dy);
(void)dz;
dealer.sample();
auto t0 = dealer.export_party(0);
auto t1 = dealer.export_party(1);
dpf::beavers::session<std::uint64_t> p0;
dpf::beavers::session<std::uint64_t> p1;
auto px0 = p0.input();
auto py0 = p0.input();
auto pz0 = p0.product(px0, py0);
auto px1 = p1.input();
auto py1 = p1.input();
auto pz1 = p1.product(px1, py1);
p0.install_party(0, t0);
p1.install_party(1, t1);
p0.bind_party(px0, 3);
p0.bind_party(py0, 4);
p1.bind_party(px1, 0);
p1.bind_party(py1, 0);
auto b0 = p0.exchange_barriers();
auto b1 = p1.exchange_barriers();
ASSERT_EQ(b0.size(), b1.size());
dpf::beavers::party_batch_stepper<std::uint64_t> step0(p0);
dpf::beavers::party_batch_stepper<std::uint64_t> step1(p1);
EXPECT_EQ(step0.barrier_count(), b0.size());
while (!step0.done())
{
auto m0 = step0.take_local();
auto m1 = step1.take_local();
ASSERT_EQ(m0.size(), m1.size());
step0.apply_peer(m1);
step1.apply_peer(m0);
}
EXPECT_TRUE(step1.done());
EXPECT_EQ(p0.value_party(pz0) + p1.value_party(pz1), 12u);
}
// ---------------------------------------------------------------------------
// Flow choreography: realistic schedules and the abstractions that unlock them.
// ---------------------------------------------------------------------------
TEST(Compose, FlowSimpleAbyProductOneRound)
{
composer c(0);
auto x = c.input(domain::a, 8);
auto y = c.input(domain::a, 8);
auto z = c.aby_product<std::uint64_t>(x, y);
(void)z;
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 1u);
}
TEST(Compose, FlowIndepFssWalksPackSameWaves)
{
composer c(0);
auto s0 = c.input(domain::fss, 16);
auto s1 = c.input(domain::fss, 16);
auto l0 = c.fss_point(s0, 5, 16);
auto l1 = c.fss_point(s1, 5, 16);
(void)l0;
(void)l1;
auto p = c.schedule();
EXPECT_EQ(p.effect_count(effect::exchange), 10u); // 5+5 slots
EXPECT_EQ(p.exchange_waves(), 5u); // packed per level
EXPECT_EQ(p.effect_count(effect::expand), 10u);
}
TEST(Compose, FlowBitMoreParallelBitWalks)
{
// Keyword PIR / BitMore: L independent bit keys, same depth — one wave/level.
composer c(0);
constexpr std::size_t L = 8;
auto seeds = c.fan(L, [&](std::size_t) {
return c.input(domain::fss, 16);
});
auto leaves = c.fan(L, [&](std::size_t i) {
return c.fss_point(seeds[i], 6, 16);
});
EXPECT_EQ(leaves.size(), L);
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 6u);
EXPECT_EQ(p.effect_count(effect::exchange), L * 6u);
}
TEST(Compose, FlowEarlyStopDropsInteractiveLevels)
{
// Pika / small-output PIR: BGI Remark 3.4 packs ν low bits into the leaf.
composer full(0);
auto seed = full.input(domain::fss, 16);
auto leaf_full = full.fss_point(seed, 8, 16);
(void)leaf_full;
auto p_full = full.schedule();
composer early(0);
auto seed_e = early.input(domain::fss, 16);
auto leaf_e = early.fss_point_early_stop(seed_e, 8, /*early_stop=*/3, 16);
EXPECT_EQ(early.domain_of(leaf_e), domain::b);
auto p_early = early.schedule();
EXPECT_EQ(p_full.exchange_waves(), 8u);
EXPECT_EQ(p_early.exchange_waves(), 5u);
EXPECT_LT(p_early.effect_count(effect::exchange),
p_full.effect_count(effect::exchange));
}
TEST(Compose, FlowPrefixCheckpointsNoExtraRounds)
{
// Poplar / idpf_agg: prefix share after each CW, still depth exchange waves.
composer c(0);
auto seed = c.input(domain::fss, 16);
auto wr = c.level_walk_prefixes(seed, 4, 16, /*prefix_bytes=*/8);
EXPECT_EQ(wr.at_level.size(), 4u);
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 4u);
EXPECT_EQ(p.effect_count(effect::exchange), 4u);
for (auto pref : wr.at_level)
EXPECT_EQ(c.domain_of(pref), domain::a);
}
TEST(Compose, FlowSizedSlotsBlockWidth)
{
// DCF block_width: CW only at checkpoints — narrower slots between.
composer c(0);
auto seed = c.input(domain::fss, 16);
const std::vector<std::size_t> slots = {16, 4, 4, 16};
auto tip = c.level_walk_sized(seed, slots);
(void)tip;
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 4u);
EXPECT_EQ(p.value_bytes_of(p.wave(0).exchanges[0].id), 16u);
EXPECT_EQ(p.value_bytes_of(p.wave(1).exchanges[0].id), 4u);
EXPECT_EQ(p.value_bytes_of(p.wave(3).exchanges[0].id), 16u);
}
TEST(Compose, FlowRssProductRefreshOneRound)
{
// 3PC Duoram-style: local rss_mul then neighbor y-exchange → RSS.
composer c(0);
auto x = c.input(domain::rss, 16);
auto y = c.input(domain::rss, 16);
auto z = c.rss_product_replicated(x, y);
EXPECT_EQ(c.domain_of(z), domain::rss);
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 1u);
EXPECT_EQ(p.effect_count(effect::exchange), 1u);
}
TEST(Compose, FlowRssChainTwoProductsTwoRounds)
{
composer c(0);
auto a = c.input(domain::rss, 16);
auto b = c.input(domain::rss, 16);
auto d = c.input(domain::rss, 16);
auto ab = c.rss_product_replicated(a, b);
auto abd = c.rss_product_replicated(ab, d);
EXPECT_EQ(c.domain_of(abd), domain::rss);
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 2u);
}
TEST(Compose, FlowIndepRssRefreshesPackOneWave)
{
composer c(0);
auto x0 = c.input(domain::rss, 16);
auto y0 = c.input(domain::rss, 16);
auto x1 = c.input(domain::rss, 16);
auto y1 = c.input(domain::rss, 16);
auto z0 = c.rss_product_replicated(x0, y0);
auto z1 = c.rss_product_replicated(x1, y1);
(void)z0;
(void)z1;
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 1u);
EXPECT_EQ(p.effect_count(effect::exchange), 2u);
}
TEST(Compose, FlowDuoramWriteScaleWaitsForLeaf)
{
// FSS leaf feeds ABY scale product — beaver flush must follow the walk.
composer c(0);
auto seed = c.input(domain::fss, 16);
auto leaf = c.fss_point(seed, 4, 16);
auto scale = c.input(domain::a, 8);
auto scaled = c.aby_product<std::uint64_t>(leaf, scale);
auto p = c.schedule();
EXPECT_GE(p.wave_of(scaled), p.wave_of(leaf));
EXPECT_GE(p.exchange_waves(), 4u);
// Factor δ that imports the leaf cannot sit in an earlier exchange wave.
bool saw_beaver_after_leaf = false;
for (std::size_t w = 0; w < p.rounds(); ++w)
{
for (auto ex : p.wave(w).exchanges)
{
if (p.opcode_of(ex.id) < opcodes::beaver_delta)
continue;
if (w >= p.wave_of(leaf))
saw_beaver_after_leaf = true;
}
}
EXPECT_TRUE(saw_beaver_after_leaf);
}
TEST(Compose, FlowWalkPlusIndepAbyPackEarlyWaves)
{
// Independent beaver product may share early CW waves (no FSS dep).
composer c(0);
auto seed = c.input(domain::fss, 16);
auto leaf = c.fss_point(seed, 3, 16);
(void)leaf;
auto x = c.input(domain::a, 8);
auto y = c.input(domain::a, 8);
auto z = c.aby_product<std::uint64_t>(x, y);
(void)z;
auto p = c.schedule();
// 3 CW waves; beaver δ packs into wave 0 alongside first CW.
EXPECT_EQ(p.exchange_waves(), 3u);
EXPECT_FALSE(p.wave(0).exchanges.empty());
EXPECT_GE(p.wave(0).exchanges.size(), 2u);
}
TEST(Compose, FlowSubleqFetchAndScale)
{
// Instruction fetch (FSS) then scale product — ABY waits for the leaf.
composer c(0);
auto pc_seed = c.input(domain::fss, 16);
auto instr = c.fss_point(pc_seed, 5, 16);
auto scale = c.input(domain::a, 8);
auto scaled = c.aby_product<std::uint64_t>(c.as(instr, domain::a), scale);
auto & s = c.aby<std::uint64_t>();
auto flag = s.input();
auto a0 = s.input();
auto a1 = s.input();
auto x = s.input();
auto lin = s(flag * (a1 * x + a0));
s.sample();
auto nlin = c.opened<std::uint64_t>(lin);
(void)nlin;
auto p = c.schedule();
EXPECT_GE(p.wave_of(scaled), p.wave_of(instr));
EXPECT_EQ(s.round_of(lin), 1);
}
TEST(Compose, FlowGrottoFanPlusSketchFuse)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto sketch = c.input(domain::a, 8);
auto leaves = c.fan(4, [&](std::size_t) {
return c.fss_cmp(seed, 3, 16);
});
auto wr = c.fss_point_fused(seed, 3, 16, sketch);
(void)leaves;
(void)wr;
auto p = c.schedule();
// Shared expands across fan + fused walk; 3 exchange waves total.
EXPECT_EQ(p.exchange_waves(), 3u);
EXPECT_EQ(p.effect_count(effect::expand), 3u);
}
TEST(Compose, FlowExpressMailboxAndAudit)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto sketch = c.input(domain::a, 8);
auto wr = c.fss_point_fused(seed, 6, 16, sketch);
EXPECT_EQ(c.domain_of(wr.trailer_open), domain::a);
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 6u);
EXPECT_EQ(p.value_bytes_of(p.wave(5).exchanges[0].id), 24u);
}
TEST(Compose, FlowReshareYUsesRssFromY)
{
composer c(0);
auto y = c.input(domain::y, 8);
auto r = c.reshare(y, domain::rss);
EXPECT_EQ(c.domain_of(r), domain::rss);
EXPECT_EQ(c.schedule().exchange_waves(), 1u);
}
TEST(Compose, FlowDsWalkFourOpensPerLevel)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto tip = c.level_walk_ds(seed, 3, 16);
(void)tip;
auto p = c.schedule();
// 3 levels × (blind, share, advice, AND1, AND2) = 15 exchange waves.
EXPECT_EQ(p.exchange_waves(), 15u);
EXPECT_EQ(p.effect_count(effect::exchange), 15u);
}
TEST(Compose, FlowDsWalkWithOhAndMux)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto tip = c.level_walk_ds(seed, 2, 16, /*oh=*/true, /*lg_outputs=*/2);
(void)tip;
auto p = c.schedule();
// 2×(5 + 80 OH) + mux_nodes=2*(4-1)=6 → 170 + 6 = 176 exchanges.
EXPECT_EQ(p.effect_count(effect::exchange), 176u);
auto budget = dpf::net::compose_ds_slot_bytes(2, 16, true, 2);
EXPECT_EQ(budget.size(), 176u);
EXPECT_EQ(p.exchange_waves(), budget.size());
}
TEST(Compose, FlowDsWalkSizedMatchesBudget)
{
composer c(0);
auto slots = dpf::net::compose_ds_slot_bytes(3, 16, false, 0);
auto tip = c.level_walk_ds_sized(c.input(domain::fss, 16), slots, false, 0);
(void)tip;
EXPECT_EQ(c.schedule().exchange_waves(), slots.size());
EXPECT_EQ(slots.size(), 15u);
}
TEST(Compose, DefaultPlanMatchesScheduleAndSink)
{
composer c(0);
auto leaf = c.fss_point(c.input(domain::fss, 16), 3, 16);
(void)leaf;
auto p = c.default_plan();
auto s = c.schedule();
EXPECT_EQ(p.rounds(), s.exchange_waves());
EXPECT_EQ(p.rounds(), p.slot_bytes_all().size());
EXPECT_EQ(p.rounds(), 3u);
}
TEST(Compose, FlowAdaptivePrefixOneWavePerStep)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto f = c.begin_adaptive_prefix(seed);
f = c.step_adaptive_prefix(f, 16, 8);
EXPECT_TRUE(f.awaiting_retain);
// After step only: one open in the plan; tip is still the prior state.
EXPECT_EQ(c.default_plan().rounds(), 1u);
f = c.retain_adaptive_prefix(f, /*child=*/0);
EXPECT_FALSE(f.awaiting_retain);
f = c.step_adaptive_prefix(f, 16, 8);
f = c.retain_adaptive_prefix(f, /*child=*/1);
auto p = c.default_plan();
EXPECT_EQ(p.exchange_waves(), 2u);
EXPECT_EQ(p.rounds(), 2u);
EXPECT_EQ(f.depth_done, 2u);
EXPECT_FALSE(f.awaiting_retain);
}
TEST(Compose, AdaptiveIncrementalDriveSkipsFlushedWaves)
{
composer c(0);
auto f = c.begin_adaptive_prefix(c.input(domain::fss, 16));
f = c.step_adaptive_prefix(f, 16, 8);
auto p = c.default_plan();
ASSERT_EQ(p.exchange_waves(), 1u);
f.exchanges_flushed = p.exchange_waves();
f = c.retain_adaptive_prefix(f, 0);
f = c.step_adaptive_prefix(f, 16, 8);
p = c.default_plan();
ASSERT_EQ(p.exchange_waves(), 2u);
auto tail = p.slot_bytes_from(f.exchanges_flushed);
EXPECT_EQ(tail.size(), 1u);
EXPECT_EQ(p.slot_bytes_from(0).size(), 2u);
// compact_sink + from_exchange_wave: RoundSink sized to the tail only.
dpf::protocol::drive_options opt;
opt.from_exchange_wave = f.exchanges_flushed;
opt.compact_sink = true;
EXPECT_EQ(opt.from_exchange_wave, 1u);
f = c.retain_adaptive_prefix(f, 1);
EXPECT_EQ(f.depth_done, 2u);
}
TEST(Compose, ReconstructOpenDomainAlgebra)
{
std::uint8_t out[8];
std::uint64_t a = 10, b = 3;
dpf::protocol::detail::reconstruct_open(domain::a, 0,
reinterpret_cast<const std::uint8_t *>(&a),
reinterpret_cast<const std::uint8_t *>(&b), 8, out);
std::uint64_t sum = 0;
std::memcpy(&sum, out, 8);
EXPECT_EQ(sum, 13u);
dpf::protocol::detail::reconstruct_open(domain::b, 0,
reinterpret_cast<const std::uint8_t *>(&a),
reinterpret_cast<const std::uint8_t *>(&b), 8, out);
std::uint64_t diff0 = 0;
std::memcpy(&diff0, out, 8);
EXPECT_EQ(diff0, 7u);
dpf::protocol::detail::reconstruct_open(domain::b, 1,
reinterpret_cast<const std::uint8_t *>(&b),
reinterpret_cast<const std::uint8_t *>(&a), 8, out);
std::uint64_t diff1 = 0;
std::memcpy(&diff1, out, 8);
EXPECT_EQ(diff1, 7u); // party1: peer - mine = 10 - 3
dpf::protocol::detail::reconstruct_open(domain::y, 0,
reinterpret_cast<const std::uint8_t *>(&a),
reinterpret_cast<const std::uint8_t *>(&b), 8, out);
std::uint64_t y = 0;
std::memcpy(&y, out, 8);
EXPECT_EQ(y, 3u);
}
TEST(Compose, FlowMultipointFanPacksAnswers)
{
composer c(0);
auto mr = c.multipoint_fan(3,
[&](std::size_t) { return c.input(domain::fss, 16); }, 4, 16, 8);
EXPECT_EQ(mr.leaves.size(), 3u);
auto p = c.schedule();
// 3×4 CW opens pack per level (4 waves) + 1 answer pack = 5.
EXPECT_EQ(p.exchange_waves(), 5u);
EXPECT_EQ(c.effect_of(mr.answers_open), effect::exchange);
}
TEST(Compose, FlowMultiLaneAbyIndependentBarriers)
{
composer c(0);
auto x0 = c.input(domain::a, 8);
auto y0 = c.input(domain::a, 8);
auto x1 = c.input(domain::a, 8);
auto y1 = c.input(domain::a, 8);
auto z0 = c.aby_product<std::uint64_t>(x0, y0, /*lane=*/0);
auto z1 = c.aby_product<std::uint64_t>(x1, y1, /*lane=*/1);
(void)z0;
(void)z1;
auto p = c.schedule();
// Two independent lane sessions — one exchange wave, two barrier nodes.
EXPECT_EQ(p.exchange_waves(), 1u);
EXPECT_EQ(p.effect_count(effect::exchange), 2u);
}
TEST(Compose, FlowDeferExpandZeroOnlineRounds)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto buf = c.defer_expand(seed, 5, 16);
auto rotated = c.rotate_share(buf, 3);
(void)rotated;
EXPECT_EQ(c.schedule().exchange_waves(), 0u);
}
TEST(Compose, FlowLeafLaterThenApply)
{
composer c(0);
auto seed = c.input(domain::fss, 16);
auto ll = c.leaf_later_walk(seed, 3, 16);
auto F = c.input(domain::a, 16);
auto done = c.apply_leaf_correction(ll.values, ll.control, F);
(void)done;
auto p = c.schedule();
EXPECT_EQ(p.exchange_waves(), 3u); // path CWs only; apply is local
}
TEST(Compose, ReshareAcrossPartyCountRefusesOpen)
{
composer c(0);
auto a = c.input(domain::a, 8);
auto rss = c.reshare(a, domain::rss);
EXPECT_EQ(c.domain_of(rss), domain::rss);
EXPECT_EQ(c.schedule().exchange_waves(), 1u);
EXPECT_THROW(c.reshare(rss, domain::a), std::invalid_argument);
composer c2(0);
auto fresh = c2.reshare_fresh(c2.input(domain::a, 8), domain::a);
(void)fresh;
EXPECT_EQ(c2.schedule().exchange_waves(), 1u);
}
TEST(Compose, ExchangeFuseOneOpen)
{
composer c(0);
auto fr = c.exchange_fuse(
{c.input(domain::a, 8), c.input(domain::a, 4)});
EXPECT_EQ(fr.segments.size(), 2u);
EXPECT_EQ(c.value_bytes(fr.opened), 12u);
EXPECT_EQ(c.schedule().exchange_waves(), 1u);
EXPECT_EQ(c.schedule().aux_of(fr.segments[1].id), 8u);
}
TEST(Compose, CuckooProbesDedupToFan)
{
composer c(0);
auto mr = c.schedule_cuckoo_probes({3, 1, 3},
[&](std::size_t) { return c.input(domain::fss, 16); }, 2, 16, 8);
EXPECT_EQ(mr.leaves.size(), 2u);
}
TEST(Compose, DealerDeliverSchedulesOneExchange)
{
composer c(2);
auto pad = c.dealer_deliver(c.input(domain::a, 16));
EXPECT_EQ(c.effect_of(pad), effect::exchange);
EXPECT_EQ(c.schedule().opcode_of(pad.id), opcodes::dealer_pad);
EXPECT_EQ(c.schedule().exchange_waves(), 1u);
}
TEST(Compose, AuthBarrierUsesOpeningWidth)
{
composer c(0);
c.aby<std::uint64_t>().set_mac_key(dpf::mac_key<std::uint64_t>{9});
auto z = c.aby_product<std::uint64_t>(c.input(domain::a, 8),
c.input(domain::a, 8));
(void)z;
auto p = c.schedule();
bool saw = false;
for (auto n : p.nodes())
{
if (p.effect_of(n.id) != effect::exchange)
continue;
if (p.opcode_of(n.id) < opcodes::beaver_delta)
continue;
saw = true;
const auto elem = sizeof(dpf::beavers::auth_opening<std::uint64_t>);
EXPECT_EQ((p.value_bytes_of(n.id) - sizeof(std::uint32_t)) % elem, 0u);
EXPECT_GT(p.value_bytes_of(n.id), sizeof(std::uint32_t) + sizeof(std::uint64_t));
}
EXPECT_TRUE(saw);
}
TEST(Compose, Fp61FieldOpen)
{
std::uint8_t out[8];
const std::uint64_t a = (std::uint64_t{1} << 61) - 2;
const std::uint64_t b = 5;
dpf::protocol::detail::reconstruct_open(domain::a, 0,
reinterpret_cast<const std::uint8_t *>(&a),
reinterpret_cast<const std::uint8_t *>(&b), 8, out,
dpf::protocol::field_open::fp61);
std::uint64_t r = 0;
std::memcpy(&r, out, 8);
// (2^61-2) ≡ -1, so -1+5 ≡ 4 in the field.
EXPECT_EQ(r, 4u);
}
TEST(Compose, BuiltinWalkKernelDrivesDefer)
{
composer c(0);
auto buf = c.defer_expand(c.input(domain::fss, 16), 3, 16);
(void)buf;
auto p = c.default_plan();
ASSERT_EQ(p.exchange_waves(), 0u);
auto [sink0, sink1] = make_memory_sink_pair(1, {});
(void)sink1;
std::vector<std::vector<std::uint8_t>> values;
std::map<std::uint32_t, kernel_fn> kernels;
EXPECT_NO_THROW(dpf::protocol::drive(p, sink0, values, kernels, 0));
}
TEST(Compose, PrgExpandMatchesAes)
{
std::uint8_t seed[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
std::uint8_t out[32] = {};
dpf::protocol::block_span in{seed, 1, 16};
dpf::protocol::block_span dst{out, 1, 32};
auto fn = dpf::protocol::detail::builtin_walk_kernel(opcodes::fss_expand_pair);
fn(opcodes::fss_expand_pair, {}, {in}, dst, 1);
simde__m128i s{};
std::memcpy(&s, seed, 16);
auto both = dpf::prg::aes128::eval01(s);
EXPECT_EQ(std::memcmp(out, both.data(), 32), 0);
}
TEST(Compose, WordOpenAddsEveryLane)
{
std::uint64_t mine[2] = {1, 2};
std::uint64_t peer[2] = {3, 4};
std::uint64_t out[2] = {};
dpf::protocol::detail::reconstruct_open(domain::a, 0,
reinterpret_cast<const std::uint8_t *>(mine),
reinterpret_cast<const std::uint8_t *>(peer), 16,
reinterpret_cast<std::uint8_t *>(out));
EXPECT_EQ(out[0], 4u);
EXPECT_EQ(out[1], 6u);
}
TEST(Compose, DsSinkCoversComposePlan)
{
auto composed = dpf::net::compose_ds_slot_bytes(4, 16, true, 1);
auto sink = dpf::net::ds_walk_slot_bytes(4, true, 1);
ASSERT_GE(sink.size(), composed.size());
for (std::size_t i = 0; i < composed.size(); ++i)
EXPECT_GE(sink[i], composed[i]);
}
TEST(Compose, IknpSetupRoundsAddToPlan)
{
const auto setup = dpf::iknp::setup_rounds(2, 1, 1, 2);
EXPECT_GT(setup, 4u);
composer c(0);
auto leaf = c.fss_point(c.input(domain::fss, 16), 3, 16);
(void)leaf;
auto p = c.default_plan();
EXPECT_EQ(p.rounds_including(setup), p.rounds() + setup);
EXPECT_EQ(p.rounds(), 3u);
}
TEST(Compose, FleetSurvivesChaoticWaits)
{
composer c(0);
auto x = c.input(domain::a, 8);
(void)c.exchange(x);
const auto t0 = std::chrono::steady_clock::now();
dpf::app::run_fleet(c, 24, 0xC0FFEEu);
const double sec = std::chrono::duration<double>(
std::chrono::steady_clock::now() - t0).count();
// Serializing every stall would be tens of seconds. Overlap keeps it small.
EXPECT_LT(sec, 0.05);
}
TEST(Compose, ClientServersTwoWavesNoServerTalk)
{
composer c(0);
EXPECT_THROW(c.client_servers(1, 8, 4), std::invalid_argument);
EXPECT_THROW(c.client_servers(2, 0, 4), std::invalid_argument);
auto q = c.client_servers(3, 16, 8);
auto p = c.default_plan();
EXPECT_EQ(p.rounds(), 2u);
EXPECT_EQ(p.slot_bytes(0), 3u * 16u);
EXPECT_EQ(p.slot_bytes(1), 3u * 8u);
EXPECT_LT(p.wave_of(q.upload), p.wave_of(q.answer));
EXPECT_EQ(p.opcode_of(q.upload.id), opcodes::client_upload);
EXPECT_EQ(p.opcode_of(q.answer.id), opcodes::client_answer);
}
TEST(Compose, ClientUploadCopiesPeerBytes)
{
composer c0(0);
composer c1(1);
auto q0 = c0.client_servers(2, 4, 4);
auto q1 = c1.client_servers(2, 4, 4);
auto p0 = c0.default_plan();
auto p1 = c1.default_plan();
auto [s0, s1] = make_memory_sink_pair(1, p0.slot_bytes_all());
std::vector<std::vector<std::uint8_t>> v0(p0.nodes().size()), v1(p1.nodes().size());
const auto src0 = p0.inputs_of(q0.upload.id)[0];
const auto src1 = p1.inputs_of(q1.upload.id)[0];
v0[src0] = {1, 2, 3, 4, 5, 6, 7, 8};
v1[src1] = {8, 7, 6, 5, 4, 3, 2, 1};
std::map<std::uint32_t, kernel_fn> kernels;
std::thread t0([&] { dpf::protocol::drive(p0, s0, v0, kernels, 0); });
std::thread t1([&] { dpf::protocol::drive(p1, s1, v1, kernels, 1); });
t0.join();
t1.join();
ASSERT_EQ(v0[q0.upload.id].size(), 8u);
EXPECT_EQ(v0[q0.upload.id][0], 8);
EXPECT_EQ(v1[q1.upload.id][0], 1);
}
TEST(Compose, ParkYieldsUntilPeerSubmits)
{
composer c0(0);
composer c1(1);
(void)c0.exchange(c0.input(domain::a, 8));
(void)c1.exchange(c1.input(domain::a, 8));
auto p0 = c0.default_plan();
auto p1 = c1.default_plan();
auto [s0, s1] = make_memory_sink_pair(1, p0.slot_bytes_all());
std::vector<std::vector<std::uint8_t>> v0, v1;
dpf::protocol::drive_cursor a, b;
dpf::protocol::drive_options opt;
opt.park_if_waiting = true;
opt.one_exchange = true;
opt.cursor = &a;
dpf::protocol::drive(p0, s0, v0, {}, 0, opt);
EXPECT_TRUE(a.awaiting_peer);
EXPECT_FALSE(a.done);
opt.cursor = &b;
dpf::protocol::drive(p1, s1, v1, {}, 1, opt);
EXPECT_FALSE(b.awaiting_peer);
opt.cursor = &a;
for (int i = 0; i < 4 && !a.done; ++i)
dpf::protocol::drive(p0, s0, v0, {}, 0, opt);
opt.cursor = &b;
for (int i = 0; i < 4 && !b.done; ++i)
dpf::protocol::drive(p1, s1, v1, {}, 1, opt);
EXPECT_TRUE(a.done);
EXPECT_TRUE(b.done);
}
TEST(Compose, OneExchangeStopsAfterFirstRound)
{
composer c0(0);
composer c1(1);
auto chain = [](composer & c) {
auto x = c.input(domain::a, 8);
auto e0 = c.exchange(x);
auto mid = c.compute(opcodes::fss_rotate, {e0}, domain::a, 8);
(void)c.exchange(mid);
};
chain(c0);
chain(c1);
auto p0 = c0.default_plan();
auto p1 = c1.default_plan();
ASSERT_EQ(p0.rounds(), 2u);
auto [s0, s1] = make_memory_sink_pair(1, p0.slot_bytes_all());
std::vector<std::vector<std::uint8_t>> v0, v1;
dpf::protocol::drive_cursor a, b;
dpf::protocol::drive_options opt;
opt.park_if_waiting = true;
opt.one_exchange = true;
auto kick = [&](auto & p, auto & sink, auto & values, auto & cur, std::size_t party) {
opt.cursor = &cur;
dpf::protocol::drive(p, sink, values, {}, party, opt);
};
kick(p0, s0, v0, a, 0);
kick(p1, s1, v1, b, 1);
kick(p0, s0, v0, a, 0);
EXPECT_FALSE(a.done);
EXPECT_FALSE(b.done);
EXPECT_EQ(a.exchange_i, 1u);
EXPECT_EQ(b.exchange_i, 1u);
EXPECT_EQ(p0.rounds(), 2u);
}
TEST(Compose, FleetOneInstanceAndEmptyPlan)
{
composer empty(0);
(void)empty.input(domain::a, 8);
dpf::app::run_fleet(empty, 4, 1);
composer one(0);
(void)one.fss_point(one.input(domain::fss, 16), 2, 16);
dpf::app::run_fleet(one, 1, 2);
EXPECT_THROW(dpf::app::run_fleet(one, 0, 3), std::invalid_argument);
}
TEST(Compose, ExerciseReportsScheduleCost)
{
composer c(0);
(void)c.fss_point_early_stop(c.input(domain::fss, 16), 8, 3, 16);
const auto got = dpf::app::exercise(c);
EXPECT_EQ(got.rounds, 5u);
EXPECT_EQ(got.bytes, 80u);
}
TEST(Compose, MissingKernelThrows)
{
composer c(0);
(void)c.compute(5000, {c.input(domain::a, 8)}, domain::a, 8);
auto p = c.default_plan();
auto [s0, s1] = make_memory_sink_pair(1, {0});
(void)s1;
std::vector<std::vector<std::uint8_t>> values;
EXPECT_THROW(dpf::protocol::drive(p, s0, values, {}, 0), std::runtime_error);
}
TEST(Compose, StepXorKernel)
{
std::uint8_t a[4] = {0xff, 0x00, 0x0f, 0xf0};
std::uint8_t b[4] = {0x0f, 0xff, 0xf0, 0x00};
std::uint8_t out[4] = {};
dpf::protocol::block_span in0{a, 1, 4};
dpf::protocol::block_span in1{b, 1, 4};
dpf::protocol::block_span dst{out, 1, 4};
auto fn = dpf::protocol::detail::builtin_walk_kernel(opcodes::fss_step + 1);
fn(opcodes::fss_step + 1, {}, {in0, in1}, dst, 1);
EXPECT_EQ(out[0], static_cast<std::uint8_t>(0xff ^ 0x0f));
EXPECT_EQ(out[1], static_cast<std::uint8_t>(0x00 ^ 0xff));
EXPECT_EQ(out[2], static_cast<std::uint8_t>(0x0f ^ 0xf0));
EXPECT_EQ(out[3], static_cast<std::uint8_t>(0xf0 ^ 0x00));
}
TEST(Compose, AdaptiveRejectsBadOrder)
{
composer c(0);
auto f = c.begin_adaptive_prefix(c.input(domain::fss, 16));
EXPECT_THROW(c.retain_adaptive_prefix(f, 0), std::logic_error);
f = c.step_adaptive_prefix(f, 16, 8);
EXPECT_THROW(c.step_adaptive_prefix(f, 16, 8), std::logic_error);
EXPECT_THROW(c.retain_adaptive_prefix(f, 2), std::invalid_argument);
f = c.retain_adaptive_prefix(f, 1);
f = c.step_adaptive_prefix(f, 16, 8);
auto p = c.default_plan();
EXPECT_EQ(p.rounds(), 2u);
EXPECT_EQ(p.slot_bytes_from(1).size(), 1u);
EXPECT_TRUE(p.slot_bytes_from(2).empty());
}
TEST(Compose, ExchangeFuseThreeSegments)
{
composer c(0);
EXPECT_THROW(c.exchange_fuse({c.input(domain::a, 4)}), std::invalid_argument);
auto fr = c.exchange_fuse({c.input(domain::a, 4), c.input(domain::a, 8),
c.input(domain::b, 2)});
ASSERT_EQ(fr.segments.size(), 3u);
auto p = c.schedule();
EXPECT_EQ(p.rounds(), 1u);
EXPECT_EQ(p.aux_of(fr.segments[0].id), 0u);
EXPECT_EQ(p.aux_of(fr.segments[1].id), 4u);
EXPECT_EQ(p.aux_of(fr.segments[2].id), 12u);
EXPECT_EQ(p.value_bytes_of(fr.opened.id), 14u);
}
TEST(Compose, ReshareFreshAndSameDomain)
{
composer c(0);
auto a = c.input(domain::a, 8);
auto same = c.reshare(a, domain::a);
EXPECT_EQ(c.domain_of(same), domain::a);
auto fresh = c.reshare_fresh(a, domain::b);
EXPECT_EQ(c.domain_of(fresh), domain::b);
auto p = c.default_plan();
EXPECT_EQ(p.rounds(), 1u);
bool saw_zero = false;
for (auto n : p.nodes())
{
if (p.opcode_of(n.id) == opcodes::dealer_zero)
saw_zero = true;
}
EXPECT_TRUE(saw_zero);
EXPECT_THROW(c.reshare_with_mask(a, c.input(domain::a, 4), domain::a),
std::invalid_argument);
}
TEST(Compose, CuckooProbesRejectsEmpty)
{
composer c(0);
EXPECT_THROW(c.schedule_cuckoo_probes({},
[&](std::size_t) { return c.input(domain::fss, 16); }, 2, 16, 8),
std::invalid_argument);
}
TEST(Compose, IknpSetupRoundsMonotone)
{
EXPECT_EQ(dpf::iknp::setup_rounds(0, 0, 0, 0), 0u);
const auto base = dpf::iknp::setup_rounds(1, 0, 0, 0);
EXPECT_GE(base, 6u);
EXPECT_GT(dpf::iknp::setup_rounds(1, 0, 0, 1), base);
EXPECT_GT(dpf::iknp::setup_rounds(1, 0, 1, 0), base);
EXPECT_GE(dpf::iknp::setup_rounds(9000, 0, 0, 0), base);
composer c(0);
(void)c.exchange(c.input(domain::a, 8));
EXPECT_EQ(c.default_plan().rounds_including(base), 1u + base);
}
TEST(Compose, DsBudgetEnvelopeSweep)
{
for (std::size_t depth : {1u, 2u, 4u})
{
for (bool oh : {false, true})
{
for (std::size_t lg : {0u, 1u, 3u})
{
auto composed = dpf::net::compose_ds_slot_bytes(depth, 16, oh, lg);
auto sink = dpf::net::ds_walk_slot_bytes(depth, oh, lg);
ASSERT_GE(sink.size(), composed.size()) << depth << oh << lg;
for (std::size_t i = 0; i < composed.size(); ++i)
EXPECT_GE(sink[i], composed[i]);
composer c(0);
(void)c.level_walk_ds(c.input(domain::fss, 16), depth, 16, oh, lg);
EXPECT_EQ(c.default_plan().rounds(), composed.size());
}
}
}
EXPECT_THROW(dpf::net::compose_ds_slot_bytes(0, 16, false), std::invalid_argument);
composer bad(0);
EXPECT_THROW(bad.level_walk_ds_sized(bad.input(domain::fss, 16), {16, 16}, false),
std::invalid_argument);
}
TEST(Compose, XorFallbackForOddWidths)
{
std::uint8_t mine[3] = {0xff, 0x00, 0x0f};
std::uint8_t peer[3] = {0x0f, 0xff, 0xf0};
std::uint8_t out[3] = {};
dpf::protocol::detail::reconstruct_open(domain::a, 0, mine, peer, 3, out);
EXPECT_EQ(out[0], static_cast<std::uint8_t>(0xff ^ 0x0f));
EXPECT_EQ(out[1], static_cast<std::uint8_t>(0x00 ^ 0xff));
EXPECT_EQ(out[2], static_cast<std::uint8_t>(0x0f ^ 0xf0));
}
TEST(Compose, DealerDeliverRejectedOnRoundSink)
{
composer c(0);
(void)c.dealer_deliver(c.input(domain::a, 8));
auto p = c.default_plan();
auto [s0, s1] = make_memory_sink_pair(1, p.slot_bytes_all());
(void)s1;
std::vector<std::vector<std::uint8_t>> values;
EXPECT_THROW(dpf::protocol::drive(p, s0, values, {}, 0), std::runtime_error);
}
TEST(Compose, DriveViaScheduleReconstructsOpen)
{
composer c0(0);
composer c1(1);
auto x0 = c0.input(domain::a, 8);
auto x1 = c1.input(domain::a, 8);
auto e0 = c0.exchange(x0);
auto e1 = c1.exchange(x1);
auto p0 = c0.schedule();
auto p1 = c1.schedule();
ASSERT_EQ(p0.rounds(), 1u);
auto [sink0, sink1] = make_memory_sink_pair(1, p0.slot_bytes_all());
std::vector<std::vector<std::uint8_t>> v0, v1;
v0.resize(p0.nodes().size());
v1.resize(p1.nodes().size());
std::uint64_t a = 3, b = 5;
v0[x0.id].assign(8, 0);
v1[x1.id].assign(8, 0);
std::memcpy(v0[x0.id].data(), &a, 8);
std::memcpy(v1[x1.id].data(), &b, 8);
std::thread t0([&] {
dpf::protocol::drive_via_schedule(p0, sink0, v0, {}, 0);
});
dpf::protocol::drive_via_schedule(p1, sink1, v1, {}, 1);
t0.join();
std::uint64_t open0 = 0, open1 = 0;
std::memcpy(&open0, v0[e0.id].data(), 8);
std::memcpy(&open1, v1[e1.id].data(), 8);
EXPECT_EQ(open0, 8u);
EXPECT_EQ(open1, 8u);
auto rounds = dpf::protocol::plan_to_schedule(p0, v0, {}, 0, 1);
ASSERT_EQ(rounds.size(), 1u);
EXPECT_EQ(rounds[0].channel, dpf::protocol::edge_channel::peer);
EXPECT_EQ(rounds[0].recv, dpf::protocol::receive_rule::domain_open);
}
TEST(Compose, DriveViaScheduleTwoWaves)
{
constexpr std::uint32_t k_step = 5000;
auto make = [](std::size_t party, std::uint64_t in) {
composer c(party);
auto x = c.input(domain::a, 8);
auto e0 = c.exchange(x);
auto y = c.compute(k_step, {e0}, domain::a, 8);
auto e1 = c.exchange(y);
return std::make_tuple(c.schedule(), x, e0, e1, in);
};
auto [p0, x0, e0a, e0b, in0] = make(0, 11);
auto [p1, x1, e1a, e1b, in1] = make(1, 19);
(void)e0a;
(void)e1a;
ASSERT_EQ(p0.rounds(), 2u);
kernel_fn step = [](std::uint32_t, const std::vector<node> &,
const std::vector<dpf::protocol::block_span> & inputs,
dpf::protocol::block_span output, std::size_t) {
std::uint64_t v = 0;
std::memcpy(&v, inputs[0].at(0), 8);
v += 1;
std::memcpy(output.at(0), &v, 8);
};
std::map<std::uint32_t, kernel_fn> k{{k_step, step}};
auto [sink0, sink1] = make_memory_sink_pair(1, p0.slot_bytes_all());
std::vector<std::vector<std::uint8_t>> v0(p0.nodes().size()), v1(p1.nodes().size());
v0[x0.id].resize(8);
v1[x1.id].resize(8);
std::memcpy(v0[x0.id].data(), &in0, 8);
std::memcpy(v1[x1.id].data(), &in1, 8);
std::thread t0([&] {
dpf::protocol::drive_via_schedule(p0, sink0, v0, k, 0);
});
dpf::protocol::drive_via_schedule(p1, sink1, v1, k, 1);
t0.join();
std::uint64_t o0 = 0, o1 = 0;
std::memcpy(&o0, v0[e0b.id].data(), 8);
std::memcpy(&o1, v1[e1b.id].data(), 8);
// First open = 11+19=30; each adds 1 locally → 31; second open = 31+31=62.
EXPECT_EQ(o0, 62u);
EXPECT_EQ(o1, 62u);
}
TEST(Compose, ScheduleBranchSkipsAfterOpen)
{
using dpf::protocol::schedule_round;
using dpf::protocol::schedule_session;
auto [sink0, sink1] = make_memory_sink_pair(1, {sizeof(std::uint64_t),
sizeof(std::uint64_t)});
std::vector<schedule_round> rounds(2);
rounds[0].slot_bytes = sizeof(std::uint64_t);
rounds[0].produce = [](std::size_t, const std::uint8_t *, std::size_t,
std::uint8_t * out) {
std::uint64_t v = 7;
std::memcpy(out, &v, 8);
};
rounds[1].slot_bytes = sizeof(std::uint64_t);
rounds[1].branch = [](std::size_t, const std::uint8_t * peer, std::size_t n) {
if (peer == nullptr || n < 8)
return true;
std::uint64_t v = 0;
std::memcpy(&v, peer, 8);
return v != 7; // peer sent 7 → prune
};
rounds[1].produce = [](std::size_t, const std::uint8_t *, std::size_t,
std::uint8_t * out) {
std::uint64_t v = 99;
std::memcpy(out, &v, 8);
};
schedule_session a(1, sink0, rounds);
schedule_session b(1, sink1, rounds);
a.submit(0);
b.submit(0);
a.drive();
b.drive();
EXPECT_TRUE(a.done(0));
EXPECT_TRUE(b.done(0));
EXPECT_FALSE(sink0.peer_ready(1, 0));
EXPECT_FALSE(sink1.peer_ready(1, 0));
}
TEST(Compose, ScheduleEdgeChannelRssNext)
{
using dpf::protocol::edge_channel;
using dpf::protocol::edge_sinks;
using dpf::protocol::schedule_round;
using dpf::protocol::schedule_session;
auto [peer0, peer1] = make_memory_sink_pair(1, {8u});
auto [rss0, rss1] = make_memory_sink_pair(1, {8u});
std::vector<schedule_round> rounds(2);
rounds[0].slot_bytes = 8;
rounds[0].channel = edge_channel::peer;
rounds[0].edge = dpf::protocol::edge_peer;
rounds[0].sink_round = 0;
rounds[0].produce = [](std::size_t, const std::uint8_t *, std::size_t,
std::uint8_t * out) {
std::uint64_t v = 1;
std::memcpy(out, &v, 8);
};
rounds[1].slot_bytes = 8;
rounds[1].channel = edge_channel::rss_next;
rounds[1].edge = dpf::protocol::edge_rss_next;
rounds[1].sink_round = 0;
rounds[1].recv = dpf::protocol::receive_rule::copy_peer;
rounds[1].produce = [](std::size_t, const std::uint8_t * peer, std::size_t n,
std::uint8_t * out) {
std::uint64_t v = 2;
if (peer != nullptr && n >= 8)
std::memcpy(&v, peer, 8);
v += 10;
std::memcpy(out, &v, 8);
};
edge_sinks e0{&peer0, &rss0, nullptr};
edge_sinks e1{&peer1, &rss1, nullptr};
schedule_session a(1, e0, rounds);
schedule_session b(1, e1, rounds);
a.submit(0);
b.submit(0);
a.drive();
b.drive();
EXPECT_TRUE(a.done(0));
EXPECT_TRUE(b.done(0));
std::uint64_t rss_peer = 0;
rss0.read_peer(0, 0, reinterpret_cast<std::uint8_t *>(&rss_peer), 8);
EXPECT_EQ(rss_peer, 11u); // peer's round0 value 1, then +10 on rss round
}
TEST(Compose, PadSetupRoundsSpliceBeforePlan)
{
composer c0(0);
composer c1(1);
auto x0 = c0.input(domain::a, 8);
auto x1 = c1.input(domain::a, 8);
(void)c0.exchange(x0);
(void)c1.exchange(x1);
auto p0 = c0.default_plan();
auto p1 = c1.default_plan();
const auto setup = dpf::iknp::setup_rounds(1, 0, 0, 0);
ASSERT_GT(setup, 0u);
auto tape0 = std::make_shared<std::vector<std::uint8_t>>();
auto tape1 = std::make_shared<std::vector<std::uint8_t>>();
std::vector<std::vector<std::uint8_t>> v0(p0.nodes().size()), v1(p1.nodes().size());
v0[x0.id].assign(8, 1);
v1[x1.id].assign(8, 2);
auto r0 = dpf::protocol::plan_with_pad_setup(p0, setup, 16, v0, {}, 0, 1, tape0);
auto r1 = dpf::protocol::plan_with_pad_setup(p1, setup, 16, v1, {}, 1, 1, tape1);
EXPECT_EQ(r0.size(), setup + p0.rounds());
EXPECT_EQ(r0[0].recv, dpf::protocol::receive_rule::xor_bytes);
EXPECT_EQ(r0[setup].sink_round, static_cast<std::uint16_t>(setup));
EXPECT_EQ(p0.rounds_including(setup), r0.size());
std::vector<std::size_t> slots;
for (const auto & r : r0)
slots.push_back(r.slot_bytes);
auto [s0, s1] = make_memory_sink_pair(1, slots);
dpf::protocol::schedule_session a(1, s0, std::move(r0));
dpf::protocol::schedule_session b(1, s1, std::move(r1));
a.submit(0);
b.submit(0);
for (unsigned spins = 0; !a.done(0) || !b.done(0); ++spins)
{
ASSERT_LT(spins, 100000u);
a.drive();
b.drive();
}
EXPECT_TRUE(a.done(0));
EXPECT_TRUE(b.done(0));
}
TEST(Compose, RssFromYTagsNeighborChannel)
{
composer c(0);
auto y = c.input(domain::y, 8);
auto r = c.rss_from_y(y);
(void)r;
auto p = c.schedule();
std::vector<std::vector<std::uint8_t>> values(p.nodes().size());
auto rounds = dpf::protocol::plan_to_schedule(p, values, {}, 0, 1);
ASSERT_EQ(rounds.size(), 1u);
EXPECT_EQ(rounds[0].channel, dpf::protocol::edge_channel::rss_next);
EXPECT_EQ(rounds[0].recv, dpf::protocol::receive_rule::copy_peer);
}
TEST(Compose, HandVsScheduleBaselineOpen)
{
// Phase 0: hand submit/flush vs interleaved drive_via_schedule — same open.
constexpr int kIters = 200;
std::uint64_t a = 3, b = 5;
const auto t_hand0 = std::chrono::steady_clock::now();
for (int i = 0; i < kIters; ++i)
{
auto [x0, x1] = make_memory_sink_pair(1, {8u});
x0.submit(0, 0, reinterpret_cast<const std::uint8_t *>(&a), 8);
x1.submit(0, 0, reinterpret_cast<const std::uint8_t *>(&b), 8);
x0.flush();
x1.flush();
std::uint64_t p0 = 0;
x0.read_peer(0, 0, reinterpret_cast<std::uint8_t *>(&p0), 8);
EXPECT_EQ(a + p0, 8u);
}
const auto hand_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
std::chrono::steady_clock::now() - t_hand0)
.count();
const auto t_sched0 = std::chrono::steady_clock::now();
for (int i = 0; i < kIters; ++i)
{
composer c0(0);
composer c1(1);
auto x0 = c0.input(domain::a, 8);
auto x1 = c1.input(domain::a, 8);
auto e0 = c0.exchange(x0);
auto e1 = c1.exchange(x1);
auto p0 = c0.schedule();
auto p1 = c1.schedule();
auto [s0, s1] = make_memory_sink_pair(1, p0.slot_bytes_all());
std::vector<std::vector<std::uint8_t>> v0(p0.nodes().size()),
v1(p1.nodes().size());
v0[x0.id].assign(8, 0);
v1[x1.id].assign(8, 0);
std::memcpy(v0[x0.id].data(), &a, 8);
std::memcpy(v1[x1.id].data(), &b, 8);
auto r0 = dpf::protocol::plan_to_schedule(p0, v0, {}, 0, 1);
auto r1 = dpf::protocol::plan_to_schedule(p1, v1, {}, 1, 1);
dpf::protocol::schedule_session a(1, s0, std::move(r0));
dpf::protocol::schedule_session b(1, s1, std::move(r1));
a.submit(0);
b.submit(0);
for (unsigned spins = 0; !a.done(0) || !b.done(0); ++spins)
{
ASSERT_LT(spins, 100000u);
a.drive();
b.drive();
}
dpf::protocol::finish_schedule(p0, s0, v0, {}, 0);
dpf::protocol::finish_schedule(p1, s1, v1, {}, 1);
std::uint64_t o = 0;
std::memcpy(&o, v0[e0.id].data(), 8);
EXPECT_EQ(o, 8u);
(void)e1;
}
const auto sched_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
std::chrono::steady_clock::now() - t_sched0)
.count();
// Correctness is the gate; print ratio for the Phase 0 harness.
EXPECT_GT(hand_ns, 0);
EXPECT_GT(sched_ns, 0);
RecordProperty("hand_ns", static_cast<int>(hand_ns));
RecordProperty("sched_ns", static_cast<int>(sched_ns));
}
TEST(Compose, StarUploadAnswerTwoServers)
{
using dpf::net::make_memory_star;
auto star = make_memory_star(2, 1, {8u, 4u});
auto queries = std::make_shared<std::vector<std::vector<std::uint8_t>>>(
std::vector<std::vector<std::uint8_t>>{{1, 2, 3, 4, 5, 6, 7, 8},
{8, 7, 6, 5, 4, 3, 2, 1}});
auto answers = std::make_shared<std::vector<std::vector<std::uint8_t>>>(
std::vector<std::vector<std::uint8_t>>{{9, 9, 9, 9}, {1, 1, 1, 1}});
auto client_rounds = dpf::protocol::star_upload_answer_graph(2, 8, 4, queries,
answers);
// Servers: on edge 0 locally, echo upload then send answer.
auto server_rounds = [&](std::size_t /*si*/,
std::vector<std::uint8_t> ans) {
std::vector<dpf::protocol::schedule_round> r(2);
r[0].slot_bytes = 8;
r[0].edge = 0;
r[0].sink_round = 0;
r[0].recv = dpf::protocol::receive_rule::copy_peer;
r[0].produce = [](std::size_t, const std::uint8_t *, std::size_t,
std::uint8_t * out) { std::memset(out, 0, 8); };
r[1].slot_bytes = 4;
r[1].edge = 0;
r[1].sink_round = 1;
r[1].recv = dpf::protocol::receive_rule::copy_peer;
r[1].produce = [ans](std::size_t, const std::uint8_t * peer,
std::size_t n, std::uint8_t * out) {
(void)peer;
(void)n;
std::memcpy(out, ans.data(), 4);
};
return r;
};
dpf::protocol::schedule_session client(1, star.client_mesh(),
std::move(client_rounds), false);
dpf::protocol::schedule_session s0(1, star.server_edge(0),
server_rounds(0, (*answers)[0]), false);
dpf::protocol::schedule_session s1(1, star.server_edge(1),
server_rounds(1, (*answers)[1]), false);
client.submit(0);
s0.submit(0);
s1.submit(0);
for (unsigned spins = 0;
!client.done(0) || !s0.done(0) || !s1.done(0); ++spins)
{
ASSERT_LT(spins, 100000u);
client.drive();
s0.drive();
s1.drive();
}
EXPECT_TRUE(client.done(0));
}
TEST(Compose, ScheduleJumpAfterOpen)
{
using dpf::protocol::schedule_round;
using dpf::protocol::schedule_session;
auto [sink0, sink1] = make_memory_sink_pair(1, {8u, 8u, 8u});
std::vector<schedule_round> rounds(3);
for (std::size_t r = 0; r < 3; ++r)
{
rounds[r].slot_bytes = 8;
rounds[r].edge = dpf::protocol::edge_peer;
rounds[r].sink_round = static_cast<std::uint16_t>(r);
rounds[r].produce = [r](std::size_t, const std::uint8_t *, std::size_t,
std::uint8_t * out) {
std::uint64_t v = r + 1;
std::memcpy(out, &v, 8);
};
}
// After round 0, jump to round 2 (skip 1).
rounds[0].next = [](std::size_t, const std::uint8_t *, std::size_t)
-> std::optional<std::uint16_t> { return std::uint16_t{2}; };
schedule_session a(1, sink0, rounds);
schedule_session b(1, sink1, rounds);
a.submit(0);
b.submit(0);
for (unsigned spins = 0; !a.done(0) || !b.done(0); ++spins)
{
ASSERT_LT(spins, 100000u);
a.drive();
b.drive();
}
EXPECT_FALSE(sink0.peer_ready(1, 0)); // skipped
EXPECT_TRUE(sink0.peer_ready(2, 0) || sink1.peer_ready(2, 0));
}
TEST(Compose, SessionHostDrivesQueuedPlans)
{
composer c0(0);
composer c1(1);
auto x0 = c0.input(domain::a, 8);
auto x1 = c1.input(domain::a, 8);
(void)c0.exchange(x0);
(void)c1.exchange(x1);
auto p0 = c0.schedule();
auto p1 = c1.schedule();
auto [s0, s1] = make_memory_sink_pair(1, p0.slot_bytes_all());
dpf::protocol::edge_mesh m0{{&s0}};
dpf::protocol::edge_mesh m1{{&s1}};
dpf::protocol::session_host h0(0, m0);
dpf::protocol::session_host h1(1, m1);
h0.values().resize(p0.nodes().size());
h1.values().resize(p1.nodes().size());
std::uint64_t a = 4, b = 6;
h0.values()[x0.id].assign(8, 0);
h1.values()[x1.id].assign(8, 0);
std::memcpy(h0.values()[x0.id].data(), &a, 8);
std::memcpy(h1.values()[x1.id].data(), &b, 8);
h0.push(p0);
h1.push(p1);
std::thread th([&] { h0.drive_until_idle(); });
h1.drive_until_idle();
th.join();
}
TEST(Compose, ApplyPeerFieldSumAndEqCheck)
{
composer c(0);
auto x = c.input(domain::a, 8);
auto e = c.exchange(x);
auto p = c.schedule();
std::vector<std::vector<std::uint8_t>> values(p.nodes().size());
values[x.id].assign(8, 0);
values[e.id].assign(8, 0);
std::uint64_t mine = 10, peer = 7;
std::memcpy(values[x.id].data(), &mine, 8);
const auto & wave = p.wave(0);
// Force field_sum via reconstruct path by calling apply with domain open
// then eq_check manually on matching tags.
dpf::protocol::drive_options opt;
opt.field = dpf::protocol::field_open::fp61;
std::uint8_t peer_bytes[8];
std::memcpy(peer_bytes, &peer, 8);
// domain_open sum
dpf::protocol::detail::apply_peer_slot(p, wave, 0, 0, 1, peer_bytes, 8,
values, opt);
std::uint64_t open = 0;
std::memcpy(&open, values[e.id].data(), 8);
EXPECT_EQ(open, 17u);
std::uint8_t tag[8] = {1, 2, 3, 4, 5, 6, 7, 8};
values[x.id].assign(tag, tag + 8);
values[e.id].assign(8, 0);
// eq_check: build a fake wave rule by direct memcmp path
EXPECT_NO_THROW({
if (std::memcmp(values[x.id].data(), tag, 8) != 0)
throw std::runtime_error("eq");
});
}
TEST(Compose, IknpAndDuAtallahPadGraphs)
{
auto tape = std::make_shared<std::vector<std::uint8_t>>();
auto ik = dpf::protocol::iknp_setup_graph(1, 0, 0, 0, tape);
EXPECT_EQ(ik.size(), dpf::iknp::setup_rounds(1, 0, 0, 0));
auto da = dpf::protocol::du_atallah_mul_graph(tape);
EXPECT_EQ(da.size(), 2u);
EXPECT_EQ(da[0].channel, dpf::protocol::edge_channel::dealer);
EXPECT_EQ(da[1].channel, dpf::protocol::edge_channel::peer);
}
TEST(Compose, PirsonaAndHushmapMicroPlans)
{
auto seeds = std::make_shared<std::vector<std::vector<std::uint8_t>>>();
auto answers = std::make_shared<std::vector<std::vector<std::uint8_t>>>();
auto fetch = dpf::protocol::pirsona_bitmore_fetch(1, 16, 8, seeds, answers);
EXPECT_EQ(fetch.size(), 4u); // 2 servers × (upload+answer)
auto tape = std::make_shared<std::vector<std::uint8_t>>();
auto add = dpf::protocol::hushmap_add_schedule(3, tape);
EXPECT_EQ(add.size(), 3u + 2u); // 3 dealer triples + 2 opens
auto p = dpf::protocol::keyword_pir_plan(0, 16, 4);
EXPECT_EQ(p.rounds(), 2u);
}
TEST(Compose, AppPlansRoundCounts)
{
EXPECT_EQ(dpf::protocol::n_server_pir_plan(0, 2, 16, 4).rounds(), 2u);
EXPECT_EQ(dpf::protocol::keyword_pir_compose_plan(0, 8).rounds(), 2u);
EXPECT_EQ(dpf::protocol::mailbox_write_fused_plan(0).rounds(), 8u);
EXPECT_EQ(dpf::protocol::bitmore_fan_plan(0).rounds(), 6u);
EXPECT_EQ(dpf::protocol::subleq_instruction_plan(0).rounds(), 8u);
EXPECT_EQ(dpf::protocol::pika_lookup_plan(0).rounds(), 5u);
EXPECT_EQ(dpf::protocol::duoram_update_plan(0).rounds(), 8u);
EXPECT_EQ(dpf::protocol::poplar_prefix_plan(0).rounds(), 8u);
EXPECT_EQ(dpf::protocol::ledger23_append_plan(0).rounds(), 2u);
EXPECT_EQ(dpf::protocol::floram_ds_plan(0).rounds(), 40u);
EXPECT_EQ(dpf::protocol::fss_point_plan(0).rounds(), 8u);
EXPECT_EQ(dpf::protocol::fss_cmp_plan(0).rounds(), 8u);
EXPECT_EQ(dpf::protocol::range_count_plan(0).rounds(), 8u);
EXPECT_EQ(dpf::protocol::psi_cuckoo_plan(0, {0, 1, 0}).rounds(), 9u);
EXPECT_EQ(dpf::protocol::idpf_agg_plan(0, 16).rounds(), 16u);
}
TEST(Compose, DriveStarUploadAnswer)
{
auto star = dpf::net::make_memory_star(2, 1, {8u, 4u});
auto queries = std::make_shared<std::vector<std::vector<std::uint8_t>>>(2);
auto answers = std::make_shared<std::vector<std::vector<std::uint8_t>>>(2);
(*queries)[0].assign(8, 1);
(*queries)[1].assign(8, 2);
(*answers)[0].assign(4, 0x10);
(*answers)[1].assign(4, 0x20);
auto client = dpf::protocol::star_upload_answer_graph(2, 8, 4, queries,
answers);
dpf::protocol::drive_star(star, std::move(client), [&](std::size_t i) {
return dpf::protocol::star_server_reply_rounds(8, 4, (*answers)[i]);
});
}
TEST(Compose, ReceiveRuleAuxTags)
{
// Aux high-byte tags select field_sum / any_two / verify / eq_check.
composer c(0);
auto x = c.input(domain::a, 8);
auto e = c.exchange(x);
auto p = c.schedule();
// Default exchange is domain_open.
EXPECT_EQ(dpf::protocol::detail::exchange_receive_rule(p, e.id),
dpf::protocol::receive_rule::domain_open);
}
TEST(Compose, ExperimentReplayUniformStream)
{
dpf::experiment::master_seed master{};
std::uint64_t a = 0, b = 0, c = 0;
{
dpf::experiment ex("replay");
master = ex.seed();
a = dpf::uniform_sample<std::uint64_t>();
b = dpf::uniform_sample<std::uint64_t>();
c = dpf::uniform_sample<std::uint64_t>();
EXPECT_GT(dpf::random_bytes_count(), 0u);
}
{
auto ex = dpf::experiment::replay("replay", master);
EXPECT_EQ(dpf::uniform_sample<std::uint64_t>(), a);
EXPECT_EQ(dpf::uniform_sample<std::uint64_t>(), b);
EXPECT_EQ(dpf::uniform_sample<std::uint64_t>(), c);
EXPECT_EQ(ex.seed_hex().size(), 64u);
}
}
TEST(Compose, ExperimentThreadsIndependentMasters)
{
dpf::experiment::master_seed s0{}, s1{};
std::uint64_t v0 = 0, v1 = 0;
std::thread t0([&] {
dpf::experiment ex("t0", "p0");
s0 = ex.seed();
v0 = dpf::uniform_sample<std::uint64_t>();
});
std::thread t1([&] {
dpf::experiment ex("t1", "p1");
s1 = ex.seed();
v1 = dpf::uniform_sample<std::uint64_t>();
});
t0.join();
t1.join();
EXPECT_NE(s0, s1);
// Distinct masters almost surely yield distinct first words.
EXPECT_NE(v0, v1);
}
TEST(Compose, MeasurePlanReportsRoundsAndSeed)
{
auto plan = dpf::protocol::fss_point_plan(0);
auto ex = dpf::app::measure_plan("fss_point", plan);
EXPECT_EQ(ex.interactive_rounds(), 8u);
EXPECT_EQ(ex.plan_bytes_out(), 128u);
EXPECT_FALSE(ex.rounds().empty());
EXPECT_GT(ex.rounds().front().bytes_out, 0u);
EXPECT_EQ(ex.seed_hex().size(), 64u);
EXPECT_GT(ex.wall_ns(), 0u);
const std::string dir = "/tmp/libdpf_experiment_csv_test";
#if defined(_WIN32)
(void)dir;
#else
(void)::system(("rm -rf " + dir + " && mkdir -p " + dir).c_str());
ex.write_csv(dir);
std::ifstream summary(dir + "/summary.csv");
ASSERT_TRUE(summary.good());
std::string header;
ASSERT_TRUE(static_cast<bool>(std::getline(summary, header)));
EXPECT_NE(header.find("master_seed"), std::string::npos);
std::string row;
ASSERT_TRUE(static_cast<bool>(std::getline(summary, row)));
EXPECT_NE(row.find("fss_point"), std::string::npos);
#endif
}
} // namespace
Reference in a new issue View git blame Copy permalink