2x faster P and NPN canonization by forcing inlining

Author: Coloquinte

src/canonization.rs

@@ -150,6 +150,7 @@ pub fn generate_swaps(num_vars: usize, rollback: bool) -> Vec<u8> {
 }
 
 /// Run all swaps on the P canonization, and return the index of the best result
+#[inline(always)]
 pub fn p_canonization_ind(
     num_vars: usize,
     table: &mut [u64],
@@ -186,6 +187,7 @@ pub fn is_p_canonical_helper(
 }
 
 /// Run all flips on the N canonization, and return the index of the best result
+#[inline(always)]
 pub fn n_canonization_ind(
     num_vars: usize,
     table: &mut [u64],
@@ -231,6 +233,7 @@ pub fn is_n_canonical_helper(
 
 /// Run all swaps on the P canonization and all flips on the N canonization,
 /// and return the index of the best result
+#[inline(always)]
 pub fn npn_canonization_ind(
     num_vars: usize,
     table: &mut [u64],
@@ -283,6 +286,7 @@ pub fn is_npn_canonical_helper(
 }
 
 /// Find the corresponding permutation given the index of the best result
+#[inline(always)]
 pub fn p_canonization_res(num_vars: usize, res_perm: &mut [u8], all_swaps: &[u8], best_ind: usize) {
     debug_assert!(best_ind == usize::MAX || best_ind < all_swaps.len());
     debug_assert_eq!(res_perm.len(), num_vars);
@@ -304,6 +308,7 @@ pub fn p_canonization_res(num_vars: usize, res_perm: &mut [u8], all_swaps: &[u8]
 }
 
 /// Find the corresponding complementation given the index of the best result
+#[inline(always)]
 pub fn n_canonization_res(num_vars: usize, all_flips: &[u8], best_ind: usize) -> u32 {
     let mut ind = 0;
     let mut cur_flip = 0;
@@ -325,6 +330,7 @@ pub fn n_canonization_res(num_vars: usize, all_flips: &[u8], best_ind: usize) ->
 }
 
 /// Find the corresponding permutation and complementation given the index of the best result
+#[inline(always)]
 pub fn npn_canonization_res(
     num_vars: usize,
     res_perm: &mut [u8],

src/operations.rs

@@ -204,6 +204,7 @@ pub fn count_zeros(num_vars: usize, table: &[u64]) -> usize {
 }
 
 /// Logical not computation
+#[inline(always)]
 pub fn not_inplace(num_vars: usize, table: &mut [u64]) {
     let mask = num_vars_mask(num_vars);
     for t in table {
@@ -370,6 +371,7 @@ pub fn fill_bin(num_vars: usize, table: &mut [u64], s: &str) -> Result<(), Parse
 }
 
 /// Swap two variables in the LUT
+#[inline(always)]
 pub fn swap_inplace(num_vars: usize, table: &mut [u64], ind1: usize, ind2: usize) {
     debug_assert_eq!(table.len(), table_size(num_vars));
     debug_assert!(ind1 < num_vars);
@@ -416,6 +418,7 @@ pub fn swap_inplace(num_vars: usize, table: &mut [u64], ind1: usize, ind2: usize
 }
 
 /// Swap two adjacent variables in the LUT
+#[inline(always)]
 pub fn swap_adjacent_inplace(num_vars: usize, table: &mut [u64], ind: usize) {
     swap_inplace(num_vars, table, ind, ind + 1);
 }
@@ -437,6 +440,7 @@ pub fn permute_inplace(num_vars: usize, table: &mut [u64], perm: &[u8]) {
     debug_assert_eq!(order, perm);
 }
 
+#[inline(always)]
 pub fn flip_inplace(num_vars: usize, table: &mut [u64], ind: usize) {
     debug_assert_eq!(table.len(), table_size(num_vars));
     debug_assert!(ind < num_vars);
@@ -457,6 +461,7 @@ pub fn flip_inplace(num_vars: usize, table: &mut [u64], ind: usize) {
     }
 }
 
+#[inline(always)]
 pub fn flip_n_inplace(num_vars: usize, table: &mut [u64], mask: u32) {
     for i in 0..num_vars {
         if ((mask >> i) & 1) != 0 {
@@ -468,6 +473,7 @@ pub fn flip_n_inplace(num_vars: usize, table: &mut [u64], mask: u32) {
     }
 }
 
+#[inline(always)]
 pub fn cofactor0_inplace(num_vars: usize, table: &mut [u64], ind: usize) {
     debug_assert_eq!(table.len(), table_size(num_vars));
     debug_assert!(ind < num_vars);
@@ -487,6 +493,7 @@ pub fn cofactor0_inplace(num_vars: usize, table: &mut [u64], ind: usize) {
     }
 }
 
+#[inline(always)]
 pub fn cofactor1_inplace(num_vars: usize, table: &mut [u64], ind: usize) {
     debug_assert_eq!(table.len(), table_size(num_vars));
     debug_assert!(ind < num_vars);