MSM - supporting all window sizes

icicle/include/api/bls12_377.h

@@ -18,23 +18,17 @@
 
 extern "C" cudaError_t bls12_377_g2_precompute_msm_bases_cuda(
   bls12_377::g2_affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bls12_377::g2_affine_t* output_bases);
 
 extern "C" cudaError_t bls12_377_g2_msm_cuda(
   const bls12_377::scalar_t* scalars, const bls12_377::g2_affine_t* points, int msm_size, msm::MSMConfig& config, bls12_377::g2_projective_t* out);
 
 extern "C" cudaError_t bls12_377_precompute_msm_bases_cuda(
   bls12_377::affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bls12_377::affine_t* output_bases);
 
 extern "C" cudaError_t bls12_377_msm_cuda(

icicle/include/api/bls12_381.h

@@ -18,23 +18,17 @@
 
 extern "C" cudaError_t bls12_381_g2_precompute_msm_bases_cuda(
   bls12_381::g2_affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bls12_381::g2_affine_t* output_bases);
 
 extern "C" cudaError_t bls12_381_g2_msm_cuda(
   const bls12_381::scalar_t* scalars, const bls12_381::g2_affine_t* points, int msm_size, msm::MSMConfig& config, bls12_381::g2_projective_t* out);
 
 extern "C" cudaError_t bls12_381_precompute_msm_bases_cuda(
   bls12_381::affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bls12_381::affine_t* output_bases);
 
 extern "C" cudaError_t bls12_381_msm_cuda(

icicle/include/api/bn254.h

@@ -19,23 +19,17 @@
 
 extern "C" cudaError_t bn254_g2_precompute_msm_bases_cuda(
   bn254::g2_affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bn254::g2_affine_t* output_bases);
 
 extern "C" cudaError_t bn254_g2_msm_cuda(
   const bn254::scalar_t* scalars, const bn254::g2_affine_t* points, int msm_size, msm::MSMConfig& config, bn254::g2_projective_t* out);
 
 extern "C" cudaError_t bn254_precompute_msm_bases_cuda(
   bn254::affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bn254::affine_t* output_bases);
 
 extern "C" cudaError_t bn254_msm_cuda(

icicle/include/api/bw6_761.h

@@ -18,23 +18,17 @@
 
 extern "C" cudaError_t bw6_761_g2_precompute_msm_bases_cuda(
   bw6_761::g2_affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bw6_761::g2_affine_t* output_bases);
 
 extern "C" cudaError_t bw6_761_g2_msm_cuda(
   const bw6_761::scalar_t* scalars, const bw6_761::g2_affine_t* points, int msm_size, msm::MSMConfig& config, bw6_761::g2_projective_t* out);
 
 extern "C" cudaError_t bw6_761_precompute_msm_bases_cuda(
   bw6_761::affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   bw6_761::affine_t* output_bases);
 
 extern "C" cudaError_t bw6_761_msm_cuda(

icicle/include/api/grumpkin.h

@@ -17,11 +17,8 @@
 
 extern "C" cudaError_t grumpkin_precompute_msm_bases_cuda(
   grumpkin::affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   grumpkin::affine_t* output_bases);
 
 extern "C" cudaError_t grumpkin_msm_cuda(

icicle/include/api/templates/curves/msm.h

@@ -1,10 +1,7 @@
 extern "C" cudaError_t ${CURVE}_precompute_msm_bases_cuda(
   ${CURVE}::affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   ${CURVE}::affine_t* output_bases);
 
 extern "C" cudaError_t ${CURVE}_msm_cuda(

icicle/include/api/templates/curves/msm_g2.h

@@ -1,10 +1,7 @@
 extern "C" cudaError_t ${CURVE}_g2_precompute_msm_bases_cuda(
   ${CURVE}::g2_affine_t* bases,
-  int bases_size,
-  int precompute_factor,
-  int _c,
-  bool are_bases_on_device,
-  device_context::DeviceContext& ctx,
+  int msm_size,
+  msm::MSMConfig& config,
   ${CURVE}::g2_affine_t* output_bases);
 
 extern "C" cudaError_t ${CURVE}_g2_msm_cuda(

icicle/include/msm/msm.cuh

@@ -43,7 +43,7 @@ namespace msm {
                               *   points, it should be set to the product of MSM size and [batch_size](@ref
                               *   batch_size). Default value: 0 (meaning it's equal to the MSM size). */
     int precompute_factor;   /**< The number of extra points to pre-compute for each point. See the
-                              *   [precompute_msm_bases](@ref precompute_msm_bases) function, `precompute_factor` passed
+                              *   [precompute_msm_points](@ref precompute_msm_points) function, `precompute_factor` passed
                               *   there needs to be equal to the one used here. Larger values decrease the
                               *   number of computations to make, on-line memory footprint, but increase the static
                               *   memory footprint. Default value: 1 (i.e. don't pre-compute). */
@@ -52,7 +52,7 @@ namespace msm {
                               *   means more on-line memory footprint but also more parallelism and less computational
                               *   complexity (up to a certain point). Currently pre-computation is independent of
                               *   \f$ c \f$, however in the future value of \f$ c \f$ here and the one passed into the
-                              *   [precompute_msm_bases](@ref precompute_msm_bases) function will need to be identical.
+                              *   [precompute_msm_points](@ref precompute_msm_points) function will need to be identical.
                               *    Default value: 0 (the optimal value of \f$ c \f$ is chosen automatically).  */
     int bitsize;             /**< Number of bits of the largest scalar. Typically equals the bitsize of scalar field,
                               *   but if a different (better) upper bound is known, it should be reflected in this
@@ -127,6 +127,26 @@ namespace msm {
   template <typename S, typename A, typename P>
   cudaError_t msm(const S* scalars, const A* points, int msm_size, MSMConfig& config, P* results);
 
+  /**
+   * A function that precomputes MSM bases by extending them with their shifted copies.
+   * e.g.:
+   * Original points: \f$ P_0, P_1, P_2, ... P_{size} \f$
+   * Extended points: \f$ P_0, P_1, P_2, ... P_{size}, 2^{l}P_0, 2^{l}P_1, ..., 2^{l}P_{size},
+   * 2^{2l}P_0, 2^{2l}P_1, ..., 2^{2cl}P_{size}, ... \f$
+   * @param points Points \f$ P_i \f$. In case of batch MSM, all *unique* points are concatenated.
+   * @param msm_size MSM size \f$ N \f$. If a batch of MSMs (which all need to have the same size) is computed, this is
+   * the size of 1 MSM.
+   * @param config [MSMConfig](@ref MSMConfig) used in this MSM.
+   * @param output_points Device-allocated buffer of size config.points_size * precompute_factor for the extended
+   * points.
+   * @tparam A The type of points \f$ \{P_i\} \f$ which is typically an [affine
+   * Weierstrass](https://hyperelliptic.org/EFD/g1p/auto-shortw.html) point.
+   * @return `cudaSuccess` if the execution was successful and an error code otherwise.
+   *
+   */
+  template <typename A, typename P>
+  cudaError_t precompute_msm_points(A* points, int msm_size, msm::MSMConfig& config, A* output_points);
+
   /**
    * A function that precomputes MSM bases by extending them with their shifted copies.
    * e.g.:
@@ -148,7 +168,7 @@ namespace msm {
    *
    */
   template <typename A, typename P>
-  cudaError_t precompute_msm_bases(
+  [[deprecated("Use precompute_msm_points instead.")]] cudaError_t precompute_msm_bases(
     A* bases,
     int bases_size,
     int precompute_factor,

icicle/src/msm/Makefile

@@ -1,4 +1,8 @@
+build_msm:
+	mkdir -p work
+	nvcc -o work/test_msm -std=c++17 -arch=sm_80 -I. -I../../include tests/msm_test.cu
+
 test_msm:
 	mkdir -p work
-	nvcc -o work/test_msm -std=c++17 -I. -I../../include tests/msm_test.cu
-	work/test_msm
+	nvcc -o work/test_msm -std=c++17 -arch=sm_80 -I.  -I../../include tests/msm_test.cu
+	work/test_msm

icicle/src/msm/extern.cu

@@ -8,6 +8,17 @@ using namespace field_config;
 #include "utils/utils.h"
 
 namespace msm {
+  /**
+   * Extern "C" version of [precompute_msm_points](@ref precompute_msm_points) function with the following values of
+   * template parameters (where the curve is given by `-DCURVE` env variable during build):
+   *  - `A` is the [affine representation](@ref affine_t) of curve points;
+   * @return `cudaSuccess` if the execution was successful and an error code otherwise.
+   */
+  extern "C" cudaError_t CONCAT_EXPAND(CURVE, precompute_msm_points_cuda)(
+    affine_t* points, int msm_size, MSMConfig& config, affine_t* output_points)
+  {
+    return precompute_msm_points<affine_t, projective_t>(points, msm_size, config, output_points);
+  }
   /**
    * Extern "C" version of [precompute_msm_bases](@ref precompute_msm_bases) function with the following values of
    * template parameters (where the curve is given by `-DCURVE` env variable during build):

icicle/src/msm/extern_g2.cu

@@ -8,6 +8,17 @@ using namespace field_config;
 #include "utils/utils.h"
 
 namespace msm {
+  /**
+   * Extern "C" version of [precompute_msm_points](@ref precompute_msm_points) function with the following values of
+   * template parameters (where the curve is given by `-DCURVE` env variable during build):
+   *  - `A` is the [affine representation](@ref g2_affine_t) of G2 curve points;
+   * @return `cudaSuccess` if the execution was successful and an error code otherwise.
+   */
+  extern "C" cudaError_t CONCAT_EXPAND(CURVE, g2_precompute_msm_points_cuda)(
+    g2_affine_t* points, int msm_size, MSMConfig& config, g2_affine_t* output_points)
+  {
+    return precompute_msm_points<g2_affine_t, g2_projective_t>(points, msm_size, config, output_points);
+  }
   /**
    * Extern "C" version of [precompute_msm_bases](@ref precompute_msm_bases) function with the following values of
    * template parameters (where the curve is given by `-DCURVE` env variable during build):
@@ -26,7 +37,6 @@ namespace msm {
     return precompute_msm_bases<g2_affine_t, g2_projective_t>(
       bases, bases_size, precompute_factor, _c, are_bases_on_device, ctx, output_bases);
   }
-
   /**
    * Extern "C" version of [msm](@ref msm) function with the following values of template parameters
    * (where the curve is given by `-DCURVE` env variable during build):