Skip to content
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

Jump to bottom

Add 64-bit version to all instructions #450

Merged
merged 4 commits into from
Sep 10, 2024
Merged

Add 64-bit version to all instructions #450

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
0220448
added 64-bit versions for all instructions (LB/SW not working)
quangvdao Aug 28, 2024
1c0fbe1
fixed loads & stores; other minor additions
quangvdao Sep 1, 2024
7f470bf
fixed clippy warning
quangvdao Sep 1, 2024
18cacef
updated `sw`
quangvdao Sep 10, 2024
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
57 changes: 44 additions & 13 deletions jolt-core/src/jolt/instruction/add.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -59,12 +59,18 @@ impl<const WORD_SIZE: usize> JoltInstruction for ADDInstruction<WORD_SIZE> {
} else if WORD_SIZE == 64 {
self.0.overflowing_add(self.1).0
} else {
panic!("only implemented for u32 / u64")
panic!("ADD is only implemented for 32-bit or 64-bit word sizes")
}
}

fn random(&self, rng: &mut StdRng) -> Self {
Self(rng.next_u32() as u64, rng.next_u32() as u64)
if WORD_SIZE == 32 {
Self(rng.next_u32() as u64, rng.next_u32() as u64)
} else if WORD_SIZE == 64 {
Self(rng.next_u64(), rng.next_u64())
} else {
panic!("Only 32-bit and 64-bit word sizes are supported")
}
}
}

Expand All @@ -82,23 +88,26 @@ mod test {
let mut rng = test_rng();
const C: usize = 4;
const M: usize = 1 << 16;
const WORD_SIZE: usize = 32;

// Random
for _ in 0..256 {
let (x, y) = (rng.next_u32() as u64, rng.next_u32() as u64);
let instruction = ADDInstruction::<32>(x, y);
let instruction = ADDInstruction::<WORD_SIZE>(x, y);
jolt_instruction_test!(instruction);
}

// Edge cases
let u32_max: u64 = u32::MAX as u64;
let instructions = vec![
ADDInstruction::<32>(100, 0),
ADDInstruction::<32>(0, 100),
ADDInstruction::<32>(1, 0),
ADDInstruction::<32>(0, u32_max),
ADDInstruction::<32>(u32_max, 0),
ADDInstruction::<32>(u32_max, u32_max),
ADDInstruction::<32>(u32_max, 1 << 8),
ADDInstruction::<32>(1 << 8, u32_max),
ADDInstruction::<WORD_SIZE>(100, 0),
ADDInstruction::<WORD_SIZE>(0, 100),
ADDInstruction::<WORD_SIZE>(1, 0),
ADDInstruction::<WORD_SIZE>(0, u32_max),
ADDInstruction::<WORD_SIZE>(u32_max, 0),
ADDInstruction::<WORD_SIZE>(u32_max, u32_max),
ADDInstruction::<WORD_SIZE>(u32_max, 1 << 8),
ADDInstruction::<WORD_SIZE>(1 << 8, u32_max),
];
for instruction in instructions {
jolt_instruction_test!(instruction);
Expand All @@ -110,10 +119,32 @@ mod test {
let mut rng = test_rng();
const C: usize = 8;
const M: usize = 1 << 16;
const WORD_SIZE: usize = 64;

// Random
for _ in 0..256 {
let (x, y) = (rng.next_u32() as u64, rng.next_u32() as u64);
let instruction = ADDInstruction::<64>(x, y);
let (x, y) = (rng.next_u64(), rng.next_u64());
let instruction = ADDInstruction::<WORD_SIZE>(x, y);
jolt_instruction_test!(instruction);
}

// Edge cases
let u64_max: u64 = u64::MAX;
let instructions = vec![
ADDInstruction::<WORD_SIZE>(100, 0),
ADDInstruction::<WORD_SIZE>(0, 100),
ADDInstruction::<WORD_SIZE>(1, 0),
ADDInstruction::<WORD_SIZE>(0, u64_max),
ADDInstruction::<WORD_SIZE>(u64_max, 0),
ADDInstruction::<WORD_SIZE>(u64_max, u64_max),
ADDInstruction::<WORD_SIZE>(u64_max, 1 << 32),
ADDInstruction::<WORD_SIZE>(1 << 32, u64_max),
ADDInstruction::<WORD_SIZE>(1 << 63, 1),
ADDInstruction::<WORD_SIZE>(1, 1 << 63),
ADDInstruction::<WORD_SIZE>(u64_max - 1, 1),
ADDInstruction::<WORD_SIZE>(1, u64_max - 1),
];
for instruction in instructions {
jolt_instruction_test!(instruction);
}
}
Expand Down
60 changes: 45 additions & 15 deletions jolt-core/src/jolt/instruction/and.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,9 +9,9 @@ use crate::jolt::subtable::{and::AndSubtable, LassoSubtable};
use crate::utils::instruction_utils::{chunk_and_concatenate_operands, concatenate_lookups};

#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize)]
pub struct ANDInstruction(pub u64, pub u64);
pub struct ANDInstruction<const WORD_SIZE: usize>(pub u64, pub u64);

impl JoltInstruction for ANDInstruction {
impl<const WORD_SIZE: usize> JoltInstruction for ANDInstruction<WORD_SIZE> {
fn operands(&self) -> (u64, u64) {
(self.0, self.1)
}
Expand All @@ -37,11 +37,18 @@ impl JoltInstruction for ANDInstruction {
}

fn lookup_entry(&self) -> u64 {
// This is the same for 32-bit and 64-bit word sizes
self.0 & self.1
}

fn random(&self, rng: &mut StdRng) -> Self {
Self(rng.next_u32() as u64, rng.next_u32() as u64)
if WORD_SIZE == 32 {
Self(rng.next_u32() as u64, rng.next_u32() as u64)
} else if WORD_SIZE == 64 {
Self(rng.next_u64(), rng.next_u64())
} else {
panic!("Only 32-bit and 64-bit word sizes are supported")
}
}
}

Expand All @@ -60,10 +67,28 @@ mod test {
let mut rng = test_rng();
const C: usize = 4;
const M: usize = 1 << 16;
const WORD_SIZE: usize = 32;

// Random
for _ in 0..256 {
let (x, y) = (rng.next_u32() as u64, rng.next_u32() as u64);
let instruction = ANDInstruction(x, y);
let instruction = ANDInstruction::<WORD_SIZE>(x, y);
jolt_instruction_test!(instruction);
}

// Edge cases
let u32_max: u64 = u32::MAX as u64;
let instructions = vec![
ANDInstruction::<WORD_SIZE>(100, 0),
ANDInstruction::<WORD_SIZE>(0, 100),
ANDInstruction::<WORD_SIZE>(1, 0),
ANDInstruction::<WORD_SIZE>(0, u32_max),
ANDInstruction::<WORD_SIZE>(u32_max, 0),
ANDInstruction::<WORD_SIZE>(u32_max, u32_max),
ANDInstruction::<WORD_SIZE>(u32_max, 1 << 8),
ANDInstruction::<WORD_SIZE>(1 << 8, u32_max),
];
for instruction in instructions {
jolt_instruction_test!(instruction);
}
}
Expand All @@ -73,25 +98,30 @@ mod test {
let mut rng = test_rng();
const C: usize = 8;
const M: usize = 1 << 16;
const WORD_SIZE: usize = 64;

// Random
for _ in 0..256 {
let (x, y) = (rng.next_u64(), rng.next_u64());
let instruction = ANDInstruction(x, y);
let instruction = ANDInstruction::<WORD_SIZE>(x, y);
jolt_instruction_test!(instruction);
}

// Test edge-cases
let u32_max: u64 = u32::MAX as u64;
// Edge cases
let u64_max: u64 = u64::MAX;
let instructions = vec![
ANDInstruction(100, 0),
ANDInstruction(0, 100),
ANDInstruction(1, 0),
ANDInstruction(0, u32_max),
ANDInstruction(u32_max, 0),
ANDInstruction(u32_max, u32_max),
ANDInstruction(u32_max, 1 << 8),
ANDInstruction(1 << 8, u32_max),
ANDInstruction::<WORD_SIZE>(100, 0),
ANDInstruction::<WORD_SIZE>(0, 100),
ANDInstruction::<WORD_SIZE>(1, 0),
ANDInstruction::<WORD_SIZE>(0, u64_max),
ANDInstruction::<WORD_SIZE>(u64_max, 0),
ANDInstruction::<WORD_SIZE>(u64_max, u64_max),
ANDInstruction::<WORD_SIZE>(u64_max, 1 << 32),
ANDInstruction::<WORD_SIZE>(1 << 32, u64_max),
ANDInstruction::<WORD_SIZE>(1 << 63, 1),
ANDInstruction::<WORD_SIZE>(1, 1 << 63),
ANDInstruction::<WORD_SIZE>(u64_max - 1, 1),
ANDInstruction::<WORD_SIZE>(1, u64_max - 1),
];
for instruction in instructions {
jolt_instruction_test!(instruction);
Expand Down
56 changes: 43 additions & 13 deletions jolt-core/src/jolt/instruction/beq.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,9 +13,9 @@ use crate::{
};

#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize)]
pub struct BEQInstruction(pub u64, pub u64);
pub struct BEQInstruction<const WORD_SIZE: usize>(pub u64, pub u64);

impl JoltInstruction for BEQInstruction {
impl<const WORD_SIZE: usize> JoltInstruction for BEQInstruction<WORD_SIZE> {
fn operands(&self) -> (u64, u64) {
(self.0, self.1)
}
Expand All @@ -41,11 +41,18 @@ impl JoltInstruction for BEQInstruction {
}

fn lookup_entry(&self) -> u64 {
// This is the same for both 32-bit and 64-bit
(self.0 == self.1).into()
}

fn random(&self, rng: &mut StdRng) -> Self {
Self(rng.next_u32() as u64, rng.next_u32() as u64)
if WORD_SIZE == 32 {
Self(rng.next_u32() as u64, rng.next_u32() as u64)
} else if WORD_SIZE == 64 {
Self(rng.next_u64(), rng.next_u64())
} else {
panic!("Only 32-bit and 64-bit word sizes are supported")
}
}
}

Expand All @@ -64,25 +71,26 @@ mod test {
let mut rng = test_rng();
const C: usize = 4;
const M: usize = 1 << 16;
const WORD_SIZE: usize = 32;

// Random
for _ in 0..256 {
let (x, y) = (rng.next_u32() as u64, rng.next_u32() as u64);
let instruction = BEQInstruction(x, y);
let instruction = BEQInstruction::<WORD_SIZE>(x, y);
jolt_instruction_test!(instruction);
}

// Test edge-cases
let u32_max: u64 = u32::MAX as u64;
let instructions = vec![
BEQInstruction(100, 0),
BEQInstruction(0, 100),
BEQInstruction(1, 0),
BEQInstruction(0, u32_max),
BEQInstruction(u32_max, 0),
BEQInstruction(u32_max, u32_max),
BEQInstruction(u32_max, 1 << 8),
BEQInstruction(1 << 8, u32_max),
BEQInstruction::<WORD_SIZE>(100, 0),
BEQInstruction::<WORD_SIZE>(0, 100),
BEQInstruction::<WORD_SIZE>(1, 0),
BEQInstruction::<WORD_SIZE>(0, u32_max),
BEQInstruction::<WORD_SIZE>(u32_max, 0),
BEQInstruction::<WORD_SIZE>(u32_max, u32_max),
BEQInstruction::<WORD_SIZE>(u32_max, 1 << 8),
BEQInstruction::<WORD_SIZE>(1 << 8, u32_max),
];
for instruction in instructions {
jolt_instruction_test!(instruction);
Expand All @@ -94,10 +102,32 @@ mod test {
let mut rng = test_rng();
const C: usize = 8;
const M: usize = 1 << 16;
const WORD_SIZE: usize = 64;

// Random
for _ in 0..256 {
let (x, y) = (rng.next_u64(), rng.next_u64());
let instruction = BEQInstruction(x, y);
let instruction = BEQInstruction::<WORD_SIZE>(x, y);
jolt_instruction_test!(instruction);
}

// Test edge-cases
let u64_max: u64 = u64::MAX;
let instructions = vec![
BEQInstruction::<WORD_SIZE>(100, 0),
BEQInstruction::<WORD_SIZE>(0, 100),
BEQInstruction::<WORD_SIZE>(1, 0),
BEQInstruction::<WORD_SIZE>(0, u64_max),
BEQInstruction::<WORD_SIZE>(u64_max, 0),
BEQInstruction::<WORD_SIZE>(u64_max, u64_max),
BEQInstruction::<WORD_SIZE>(u64_max, 1 << 32),
BEQInstruction::<WORD_SIZE>(1 << 32, u64_max),
BEQInstruction::<WORD_SIZE>(1 << 63, 1),
BEQInstruction::<WORD_SIZE>(1, 1 << 63),
BEQInstruction::<WORD_SIZE>(u64_max - 1, u64_max),
BEQInstruction::<WORD_SIZE>(u64_max, u64_max - 1),
];
for instruction in instructions {
jolt_instruction_test!(instruction);
}
}
Expand Down
Loading
Loading