From bf4c3ee4ca71c928e978aafaca2083cdaa7badf7 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 19:02:37 +0100 Subject: [PATCH 1/3] refactor: Remove unneded prints and change gfmul --- Cargo.toml | 4 ++++ src/utils/ciphers.rs | 37 ------------------------------------- src/utils/edf.rs | 6 ------ src/utils/field.rs | 3 --- src/utils/poly.rs | 31 +++++-------------------------- 5 files changed, 9 insertions(+), 72 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 28fc780..9cf5fa2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,3 +18,7 @@ replace-with = "vendored-sources" [source.vendored-sources] directory = "vendor" + +[profile.profiling] +inherits = "release" +debug = true diff --git a/src/utils/ciphers.rs b/src/utils/ciphers.rs index 35181a5..82af34b 100644 --- a/src/utils/ciphers.rs +++ b/src/utils/ciphers.rs @@ -119,10 +119,8 @@ pub fn gcm_encrypt_aes( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); let auth_tag_xor = aes_128_encrypt(&key, &nonce)?; - eprintln!("Y0 {:001X?}", auth_tag_xor); let auth_key_h = aes_128_encrypt(&key, &0u128.to_be_bytes().to_vec())?; @@ -133,8 +131,6 @@ pub fn gcm_encrypt_aes( nonce.drain(12..); nonce.append(counter.to_be_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); - let inter1 = aes_128_encrypt(&key, &nonce)?; let mut inter2 = xor_bytes(&inter1, chunk.clone())?; @@ -151,7 +147,6 @@ pub fn gcm_encrypt_aes( &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?, auth_tag_xor, )?; - eprintln!("aes auth tag: {:001X?}", &auth_tag); Ok((ciphertext, auth_tag, l_field, auth_key_h)) } @@ -168,7 +163,6 @@ pub fn gcm_decrypt_aes( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); let auth_tag_xor = aes_128_encrypt(&key, &nonce)?; @@ -181,8 +175,6 @@ pub fn gcm_decrypt_aes( nonce.drain(12..); nonce.append(counter.to_be_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); - let inter1 = aes_128_encrypt(&key, &nonce)?; let mut inter2 = xor_bytes(&inter1, chunk.clone())?; @@ -201,7 +193,6 @@ pub fn gcm_decrypt_aes( )?; let valid = auth_tag == tag; - eprintln!("aes auth tag: {:001X?}", auth_tag); Ok((plaintext, valid)) } @@ -217,7 +208,6 @@ pub fn gcm_encrypt_sea( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); let auth_tag_xor = sea_128_encrypt(&key, &nonce)?; @@ -230,8 +220,6 @@ pub fn gcm_encrypt_sea( nonce.drain(12..); nonce.append(counter.to_be_bytes().to_vec().as_mut()); - eprintln!("{:001X?}", nonce); - let inter1 = sea_128_encrypt(&key, &nonce)?; let mut inter2 = xor_bytes(&inter1, chunk.clone())?; @@ -264,7 +252,6 @@ pub fn gcm_decrypt_sea( let mut counter: u32 = 1; nonce.append(counter.to_be_bytes().to_vec().as_mut()); //nonce.append(0u8.to_le_bytes().to_vec().as_mut()); - eprintln!("Nonce 1: {:001X?}", nonce); let auth_tag_xor = sea_128_encrypt(&key, &nonce)?; @@ -272,17 +259,11 @@ pub fn gcm_decrypt_sea( let plaintext_chunks: Vec> = ciphertext.chunks(16).map(|x| x.to_vec()).collect(); - eprintln!("{:?}", plaintext_chunks); - counter = 2; for chunk in plaintext_chunks { - eprintln!("Inside loop"); - nonce.drain(12..); nonce.append(counter.to_be_bytes().to_vec().as_mut()); - eprintln!("Nonce 2: {:001X?}", nonce); - let inter1 = sea_128_encrypt(&key, &nonce)?; let mut inter2 = xor_bytes(&inter1, chunk.clone())?; @@ -295,15 +276,11 @@ pub fn gcm_decrypt_sea( let mut c_len: Vec = ((plaintext.len() * 8) as u64).to_be_bytes().to_vec(); l_field.append(c_len.as_mut()); - eprintln!("Ciphertext: {}", BASE64_STANDARD.encode(&ciphertext)); - let auth_tag = xor_bytes( &ghash(auth_key_h.clone(), ad, ciphertext.clone(), l_field.clone())?, auth_tag_xor, )?; - eprintln!("sea dec auth tag: {}", BASE64_STANDARD.encode(&auth_tag)); - let valid = auth_tag == tag; Ok((plaintext, valid)) @@ -317,10 +294,6 @@ pub fn ghash( ) -> Result> { let output: Vec = vec![0; 16]; - eprintln!("{:?}", ad.len() as u8); - eprintln!("{:?}", (ad.len() % 16) as u8); - eprintln!("{:001X?}", ad); - if ad.len() % 16 != 0 || ad.is_empty() { ad.append(vec![0u8; 16 - (ad.len() % 16)].as_mut()); } @@ -329,20 +302,12 @@ pub fn ghash( ciphertext.append(vec![0u8; 16 - (ciphertext.len() % 16)].as_mut()); } - eprintln!("{:001X?}", ad); - eprintln!("{:001X?}", ciphertext); - let mut ad_chunks = ad.chunks(16); - eprintln!("Ad chunks before first next {:001X?}", ad_chunks); - let inter1 = xor_bytes(&output, ad_chunks.next().unwrap().to_vec())?; let mut inter_loop = gfmul(&inter1, &auth_key_h, "gcm")?; - eprintln!("Ad chunks after first next {:001X?}", ad_chunks); for chunk in ad_chunks { - eprintln!("Inside ad chunk loop"); - eprintln!("Ad chunk in loop {:001X?}", chunk); let inter2 = xor_bytes(&inter_loop, chunk.to_vec())?; inter_loop = gfmul(&inter2, &auth_key_h, "gcm")?; } @@ -357,8 +322,6 @@ pub fn ghash( let inter4 = xor_bytes(&inter_loop, l_field)?; inter_loop = gfmul(&inter4, &auth_key_h, "gcm")?; - eprintln!("GHASH auth tag: {:001X?}", inter_loop); - Ok(inter_loop) } diff --git a/src/utils/edf.rs b/src/utils/edf.rs index 80f552c..72f687d 100644 --- a/src/utils/edf.rs +++ b/src/utils/edf.rs @@ -1,12 +1,9 @@ use num::{BigUint, FromPrimitive, One}; use rand::Rng; - use super::poly::{gcd, Polynomial}; pub fn edf(f: Polynomial, d: u32) -> Vec { - eprintln!("Starting edf"); - let q = BigUint::pow(&BigUint::from_u8(2).unwrap(), 128); let n: u32 = (f.degree() as u32) / (d); let mut z: Vec = vec![f.clone()]; @@ -20,7 +17,6 @@ pub fn edf(f: Polynomial, d: u32) -> Vec { //eprintln!("h: {:02X?}", h); let exponent = (q.pow(d) - BigUint::one()) / BigUint::from_u8(3).unwrap(); - eprintln!("q before for {:0X?}", exponent); let g = h.bpow_mod(exponent, &f) + Polynomial::one(); //eprintln!("g before for {:0X?}", g); @@ -32,9 +28,7 @@ pub fn edf(f: Polynomial, d: u32) -> Vec { //eprintln!("Inside if"); let j = gcd(&z[i], &g); - eprintln!("j: {:02X?}", j); if j != one_cmp && j != z[i] { - eprintln!("Working on Z"); let intemediate = z[i].div(&j).0; z.remove(i); z.push(j.clone()); diff --git a/src/utils/field.rs b/src/utils/field.rs index 9b9876b..4876271 100644 --- a/src/utils/field.rs +++ b/src/utils/field.rs @@ -55,15 +55,12 @@ impl FieldElement { let mut result: FieldElement = FieldElement::one(); if exponent == 1 { - eprintln!("special case 1: {:02X?}", self.clone()); - return self; } if exponent == 0 { let result = FieldElement::one(); - eprintln!("Returned value is: {:02X?}", result); return result; } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 68edb82..3816dac 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -70,8 +70,6 @@ impl Polynomial { }) .collect(); - eprintln!("{:?}", c_array); - for coefficient in c_array { polynomial.push(FieldElement::new( BASE64_STANDARD @@ -97,8 +95,6 @@ impl Polynomial { )]); if exponent == 1 { - eprintln!("special case 1: {:02X?}", self.clone()); - return self; } @@ -107,7 +103,6 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); - eprintln!("Returned value is: {:02X?}", result); return result; } @@ -159,8 +154,6 @@ impl Polynomial { )]); if exponent == BigUint::one() { - eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); - return self.div(&modulus).1; } @@ -169,7 +162,6 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); - eprintln!("Returned value is: {:02X?}", result); return result; } @@ -213,8 +205,6 @@ impl Polynomial { )]); if exponent == 1 { - eprintln!("special case 1: {:02X?}", self.clone().div(&modulus).1); - return self.div(&modulus).1; } @@ -223,7 +213,6 @@ impl Polynomial { polynomial_2_block(vec![0], "gcm").unwrap(), )]); - eprintln!("Returned value is: {:02X?}", result); return result; } @@ -243,8 +232,6 @@ impl Polynomial { exponent >>= 1; } - eprintln!("result in powmod before reduction: {:02X?}", result); - while !result.polynomial.is_empty() && result .polynomial @@ -257,8 +244,6 @@ impl Polynomial { result.polynomial.pop(); } - eprintln!("result in powmod after reduction: {:02X?}", result); - if result.is_empty() { result = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); } @@ -528,12 +513,6 @@ impl PartialOrd for Polynomial { for (field_a, field_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { - eprintln!( - "Poly partord: {:02X?} {:02X?} ", - self.clone().to_c_array(), - other.clone().to_c_array() - ); - match field_a .reverse_bits() .partial_cmp(&field_b.reverse_bits()) @@ -616,10 +595,10 @@ pub fn gfmul(poly_a: &Vec, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result, poly_b: &Vec, semantic: &str) -> Result) -> Result> { From 2623bd9a8d9807c56c58e2ef7f83e59e000d9e62 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 19:31:10 +0100 Subject: [PATCH 2/3] refactor: Change initialisations of field elements to be cleaner --- src/utils/poly.rs | 65 +++++++++++++++-------------------------------- 1 file changed, 21 insertions(+), 44 deletions(-) diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 3816dac..969a144 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -32,15 +32,13 @@ impl Polynomial { } pub fn one() -> Self { - Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]) + Polynomial::new(vec![FieldElement::one()]) } pub fn x() -> Self { Polynomial::new(vec![ FieldElement::new(vec![0; 16]), - FieldElement::new(polynomial_2_block(vec![0], "gcm").unwrap()), + FieldElement::new(polynomial_2_block(vec![0], "xex").unwrap()), ]) } @@ -54,7 +52,7 @@ impl Polynomial { } pub fn zero() -> Self { - Polynomial::new(vec![FieldElement::new(vec![0; 16])]) + Polynomial::new(vec![FieldElement::zero()]) } pub fn from_c_array(array: &Value) -> Self { @@ -83,7 +81,7 @@ impl Polynomial { pub fn to_c_array(self) -> Vec { let mut output: Vec = vec![]; for coeff in self.polynomial { - output.push(BASE64_STANDARD.encode(coeff)); + output.push(coeff.to_b64()); } output @@ -209,9 +207,7 @@ impl Polynomial { } if exponent == 0 { - let result = Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0], "gcm").unwrap(), - )]); + let result = Polynomial::new(vec![FieldElement::one()]); return result; } @@ -258,10 +254,7 @@ impl Polynomial { //eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); if self.polynomial.len() < rhs.polynomial.len() { - return ( - Polynomial::new(vec![FieldElement::new(vec![0; 16])]), - self.clone(), - ); + return (Polynomial::new(vec![FieldElement::zero()]), self.clone()); } let mut remainder = self.clone(); @@ -270,16 +263,10 @@ impl Polynomial { let divisor_deg = divisor.polynomial.len() - 1; if dividend_deg < divisor_deg { - return ( - Polynomial::new(vec![FieldElement::new( - polynomial_2_block(vec![0; 16], "gcm").unwrap(), - )]), - remainder, - ); + return (Polynomial::new(vec![FieldElement::zero()]), remainder); } - let mut quotient_coeffs = - vec![FieldElement::new(vec![0; 16]); dividend_deg - divisor_deg + 1]; + let mut quotient_coeffs = vec![FieldElement::zero(); dividend_deg - divisor_deg + 1]; while remainder.polynomial.len() >= divisor.polynomial.len() { let deg_diff = remainder.polynomial.len() - divisor.polynomial.len(); @@ -290,7 +277,7 @@ impl Polynomial { quotient_coeffs[deg_diff] = quot_coeff.clone(); - let mut subtrahend = vec![FieldElement::new(vec![0; 16]); deg_diff]; + let mut subtrahend = vec![FieldElement::zero(); deg_diff]; subtrahend.extend( divisor .polynomial @@ -315,7 +302,7 @@ impl Polynomial { } if remainder.is_empty() { - remainder = Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + remainder = Polynomial::new(vec![FieldElement::zero()]); } (Polynomial::new(quotient_coeffs), remainder) } @@ -416,10 +403,10 @@ impl Mul for Polynomial { type Output = Self; fn mul(self, rhs: Self) -> Self::Output { if self.is_zero() || rhs.is_zero() { - return Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + return Polynomial::zero(); } let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; + vec![FieldElement::zero(); self.polynomial.len() + rhs.polynomial.len() - 1]; for i in 0..self.polynomial.len() { for j in 0..rhs.polynomial.len() { polynomial[i + j] = &polynomial[i + j] @@ -434,10 +421,10 @@ impl Mul for &Polynomial { type Output = Polynomial; fn mul(self, rhs: Self) -> Self::Output { if self.is_zero() || rhs.is_zero() { - return Polynomial::new(vec![FieldElement::new(vec![0])]); + return Polynomial::zero(); } let mut polynomial: Vec = - vec![FieldElement::new(vec![0; 16]); self.polynomial.len() + rhs.polynomial.len() - 1]; + vec![FieldElement::zero(); self.polynomial.len() + rhs.polynomial.len() - 1]; for i in 0..self.polynomial.len() { for j in 0..rhs.polynomial.len() { polynomial[i + j] = &polynomial[i + j] @@ -471,7 +458,7 @@ impl Add for Polynomial { } if polynomial.is_empty() { - return Polynomial::new(vec![FieldElement::new(vec![0; 16])]); + return Polynomial::new(vec![FieldElement::zero()]); } Polynomial::new(polynomial) @@ -514,8 +501,8 @@ impl PartialOrd for Polynomial { self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { match field_a - .reverse_bits() - .partial_cmp(&field_b.reverse_bits()) + //.reverse_bits() + .partial_cmp(&field_b) .unwrap() { Ordering::Equal => continue, @@ -538,7 +525,10 @@ impl Ord for Polynomial { for (field_a, field_b) in self.as_ref().iter().rev().zip(other.as_ref().iter().rev()) { - match field_a.reverse_bits().cmp(&field_b.reverse_bits()) { + match field_a + //.reverse_bits() + .cmp(&field_b) + { Ordering::Equal => continue, other => return other, } @@ -1115,19 +1105,6 @@ mod tests { //assert_eq!(BASE64_STANDARD.encode(product), "MoAAAAAAAAAAAAAAAAAAAA=="); } - #[test] - fn test_poly_div_01() { - let element1 = - FieldElement::new(BASE64_STANDARD.decode("JAAAAAAAAAAAAAAAAAAAAA==").unwrap()); - - let element2 = - FieldElement::new(BASE64_STANDARD.decode("wAAAAAAAAAAAAAAAAAAAAA==").unwrap()); - - let result = element1 / element2; - - assert_eq!(BASE64_STANDARD.encode(result), "OAAAAAAAAAAAAAAAAAAAAA=="); - } - #[test] fn test_field_poly_div_01() { let json1 = json!([ From 7dbcf20891716b64dc653dc5b57b5903c17d1009 Mon Sep 17 00:00:00 2001 From: Alivecow Date: Fri, 29 Nov 2024 21:12:42 +0100 Subject: [PATCH 3/3] feat/fix: add initial MT and remove extend from div for performance --- Cargo.toml | 2 ++ src/main.rs | 2 +- src/tasks/mod.rs | 71 +++++++++++++++++++++++++++++++++++++--------- src/utils/parse.rs | 4 +-- src/utils/poly.rs | 28 ++++++------------ 5 files changed, 71 insertions(+), 36 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 9cf5fa2..0d58d2b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,8 @@ serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" num = "0.4" rand = "0.8" +threadpool = "1.8" +num_cpus = "1.16.0" [source.crates-io] replace-with = "vendored-sources" diff --git a/src/main.rs b/src/main.rs index fd69ac4..0bb3127 100644 --- a/src/main.rs +++ b/src/main.rs @@ -14,7 +14,7 @@ fn main() -> Result<()> { let json = fs::read_to_string(path_to_workload).unwrap(); let workload = kauma::utils::parse::parse_json(json)?; - let response = kauma::tasks::task_distrubute(&workload)?; + let response = kauma::tasks::task_distribute(&workload)?; println!("{}", serde_json::to_string(&response)?); Ok(()) diff --git a/src/tasks/mod.rs b/src/tasks/mod.rs index d2c57b7..d86e661 100644 --- a/src/tasks/mod.rs +++ b/src/tasks/mod.rs @@ -185,16 +185,61 @@ pub fn task_deploy(testcase: &Testcase) -> Result { } } -pub fn task_distrubute(testcases: &Testcases) -> Result { +fn task_distribute_mt(testcases: &Testcases) -> Result { + eprintln!("USING MULTITHREADED"); + let mut responses: HashMap = HashMap::new(); + let pool = threadpool::ThreadPool::default(); + let (tx, rx) = std::sync::mpsc::channel(); + for (key, testcase) in testcases.testcases.clone() { + let tx = tx.clone(); + let testcase = testcase.clone(); + pool.execute(move || { + tx.send((key, task_deploy(&testcase))) + .expect("could not send return value of thread to main thread") + }); + } + + for _ in 0..testcases.testcases.len() { + let result = match rx.recv_timeout(std::time::Duration::from_secs(60 * 5)) { + Ok(r) => r, + Err(e) => { + eprintln!("! Job timed out: {e}"); + return Err(e.into()); + } + }; + match result.1 { + Ok(v) => { + let _ = responses.insert(result.0, v); + } + Err(e) => { + eprintln!("! failed to solve a challenge: {e:#}"); + continue; + } + } + } + + Ok(Responses { responses }) +} + +pub fn task_distribute_st(testcases: &Testcases) -> Result { + //eprintln!("USING SINGLETHREADED"); let mut responses: HashMap = HashMap::new(); for (id, testcase) in &testcases.testcases { responses.insert(id.to_owned(), task_deploy(testcase).unwrap()); } - Ok(Responses { - responses: responses, - }) + Ok(Responses { responses }) +} + +pub fn task_distribute(testcases: &Testcases) -> Result { + let cpus = num_cpus::get(); + //TODO: Deactivate MT for now + if cpus > 10000000000 { + task_distribute_mt(testcases) + } else { + task_distribute_st(testcases) + } } #[cfg(test)] @@ -227,7 +272,7 @@ mod tests { let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"block": "ARIAAAAAAAAAAAAAAAAAgA=="}}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -251,7 +296,7 @@ mod tests { }); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -266,7 +311,7 @@ mod tests { let expected = json!({ "responses": { "b856d760-023d-4b00-bad2-15d2b6da22fe": {"product": "hSQAAAAAAAAAAAAAAAAAAA=="}}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -284,7 +329,7 @@ mod tests { }}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -304,7 +349,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -324,7 +369,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -342,7 +387,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -360,7 +405,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); @@ -378,7 +423,7 @@ mod tests { }}}); assert_eq!( - serde_json::to_value(task_distrubute(&parsed)?).unwrap(), + serde_json::to_value(task_distribute(&parsed)?).unwrap(), serde_json::to_value(expected).unwrap() ); diff --git a/src/utils/parse.rs b/src/utils/parse.rs index 6e5d2dd..4b71b29 100644 --- a/src/utils/parse.rs +++ b/src/utils/parse.rs @@ -8,13 +8,13 @@ pub struct Testcases { pub testcases: HashMap, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, Clone)] pub struct Testcase { pub action: String, pub arguments: Value, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, Clone)] pub struct Responses { pub responses: HashMap, } diff --git a/src/utils/poly.rs b/src/utils/poly.rs index 969a144..c294ccb 100644 --- a/src/utils/poly.rs +++ b/src/utils/poly.rs @@ -247,12 +247,7 @@ impl Polynomial { result } - // Returns (quotient, remainder) pub fn div(&self, rhs: &Self) -> (Self, Self) { - // Div by zero check ommitted since data is guaranteed to be non 0 - - //eprintln!("{:?}, {:?}", self.polynomial.len(), rhs.polynomial.len()); - if self.polynomial.len() < rhs.polynomial.len() { return (Polynomial::new(vec![FieldElement::zero()]), self.clone()); } @@ -270,24 +265,20 @@ impl Polynomial { while remainder.polynomial.len() >= divisor.polynomial.len() { let deg_diff = remainder.polynomial.len() - divisor.polynomial.len(); - let leading_dividend = remainder.polynomial.last().unwrap(); let leading_divisor = divisor.polynomial.last().unwrap(); let quot_coeff = leading_dividend / leading_divisor; - quotient_coeffs[deg_diff] = quot_coeff.clone(); - let mut subtrahend = vec![FieldElement::zero(); deg_diff]; - subtrahend.extend( - divisor - .polynomial - .iter() - .map(|x| x.clone() * quot_coeff.clone()), - ); - let subtrahend_poly = Polynomial::new(subtrahend); - - remainder = remainder + subtrahend_poly; + let mut pos; + for (i, divisor_coeff) in divisor.polynomial.iter().enumerate() { + pos = deg_diff + i; + let a: &FieldElement = &remainder.polynomial[pos]; + let c: &FieldElement = "_coeff; + remainder.polynomial[pos] = a + &(divisor_coeff * c); + } + // Remove trailing zeros while !remainder.polynomial.is_empty() && remainder .polynomial @@ -301,9 +292,6 @@ impl Polynomial { } } - if remainder.is_empty() { - remainder = Polynomial::new(vec![FieldElement::zero()]); - } (Polynomial::new(quotient_coeffs), remainder) }