// Checks only signed, windowed point addition for which there are fixed parameters. public static void EstimateFixedEllipticCurveArithmetic(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); System.IO.Directory.CreateDirectory(directory); // Loops over controlled/not and whether it counts all gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { var localControl = isControlled; var localGates = allGates; Thread fixedThread = new Thread(() => BasicResourceTest <FixedEllipticCurveSignedWindowedPointAdditionEstimator>( FixedEllipticCurveSignedWindowedPointAdditionEstimator.Run, testSizes, false, directory + "Fixed-modulus-signed", localGates, true)); fixedThread.Start(); allGates = !allGates; } }
public static void EstimateLookup(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); System.IO.Directory.CreateDirectory(directory); // Loops over controlled/not and whether it counts all gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { for (int i = 0; i < 2; i++) { var localControl = isControlled; var localGates = allGates; Thread lookupThread = new Thread(() => BasicResourceTest <LookUpEstimator>( LookUpEstimator.Run, testSizes, localControl, directory + "Lookup", localGates, true)); lookupThread.Start(); isControlled = !isControlled; } allGates = !allGates; } }
// Estimates how large an optimal window should be, by iterating through // all possible window sizes and checking total cost. // This is an extremely costly estimate to run. public static void EstimatePointAdditionWindowSizes(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); // Guesses int[] minWindowSizes = { 14, 15, 15, 15, 16, 16, 16 }; int[] maxWindowSizes = { 18, 18, 18, 18, 20, 20, 20 }; System.IO.Directory.CreateDirectory(directory); bool allGates = false; bool isControlled = false; var localControl = isControlled; var localGates = allGates; Thread lowWidthThread = new Thread(() => ParameterizedResourceTest <EllipticCurveWindowedPointAdditionLowWidthWindowTest>( EllipticCurveWindowedPointAdditionLowWidthWindowTest.Run, testSizes, localControl, true, true, directory + "Point-addition-windowed-low-width", localGates, minWindowSizes, maxWindowSizes)); lowWidthThread.Start(); Thread highWidthThread = new Thread(() => ParameterizedResourceTest <EllipticCurveWindowedPointAdditionWindowTest>( EllipticCurveWindowedPointAdditionWindowTest.Run, testSizes, localControl, true, true, directory + "Point-addition-windowed", localGates, minWindowSizes, maxWindowSizes)); highWidthThread.Start(); Thread signedThread = new Thread(() => ParameterizedResourceTest <EllipticCurveSignedWindowedPointAdditionWindowTest>( EllipticCurveSignedWindowedPointAdditionWindowTest.Run, testSizes, localControl, true, true, directory + "Point-addition-windowed-signed", localGates, minWindowSizes, maxWindowSizes)); signedThread.Start(); }
// Estimates window sizes for modular arithmetic // See ReadMe public static void EstimateModularMultiplicationWindowSizes(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); // Construct window size maximum and minimum values // Idea: Minimum value is 0 (no windowing), maximum value is the full // size, or a value which is too large to reasonably simulate int[] minWindowSizes = new int[testSizes.Length]; int[] maxWindowSizes = new int[testSizes.Length]; for (int i = 0; i < testSizes.Length; i++) { minWindowSizes[i] = 0; maxWindowSizes[i] = Math.Min(testSizes[i], 23); // 2^23 should take about 2 hours } System.IO.Directory.CreateDirectory(directory); // Loops over controlled/not and whether it counts all gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { for (int i = 0; i < 2; i++) { var localControl = isControlled; var localGates = allGates; Thread multiplyThread = new Thread(() => ParameterizedResourceTestSingleThreaded <MontgomeryWindowedMultiplicationWindowTest>( MontgomeryWindowedMultiplicationWindowTest.Run, testSizes, localControl, false, directory + "Modular-multiplication-windowed", localGates, minWindowSizes, maxWindowSizes)); multiplyThread.Start(); isControlled = !isControlled; } allGates = !allGates; } }
// Estimates cost to look up points for a number of window sizes // if the points have a specific bitlength. public static void EstimatePointLookups(int[] testSizes, string directory) { var maxWindowSize = 10; // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); // Construct window size maximum and minimum values // Idea: Minimum value is 1, maximum value is the full // size, or a value which is too large to reasonably simulate int[] minWindowSizes = new int[testSizes.Length]; int[] maxWindowSizes = new int[testSizes.Length]; for (int i = 0; i < testSizes.Length; i++) { minWindowSizes[i] = 1; maxWindowSizes[i] = Math.Min(testSizes[i], maxWindowSize); // 2^23 should take about 2 hours } System.IO.Directory.CreateDirectory(directory); // Loops over whether it counts all all-gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { // Creates a new thread for each operation being estimated var localControl = isControlled; var localGates = allGates; Thread lookupThread = new Thread(() => ParameterizedResourceTest <PointLookUpEstimator>( PointLookUpEstimator.Run, testSizes, localControl, false, true, directory + "Point-lookup", localGates, minWindowSizes, maxWindowSizes)); lookupThread.Start(); allGates = !allGates; } }
// Estimates modular addition-like operations, which can be reasonable // estimated for bit sizes over 500 public static void EstimateCheapModularArithmetic(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); System.IO.Directory.CreateDirectory(directory); // Loops over controlled/not and whether it counts all gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { for (int i = 0; i < 2; i++) { var localControl = isControlled; var localGates = allGates; Thread doubleThread = new Thread(() => BasicResourceTest <ModularDblEstimator>( ModularDblEstimator.Run, testSizes, localControl, directory + "Modular-double", localGates, false)); doubleThread.Start(); Thread additionThread = new Thread(() => BasicResourceTest <ModularAdditionEstimator>( ModularAdditionEstimator.Run, testSizes, localControl, directory + "Modular-addition", localGates, false)); additionThread.Start(); isControlled = !isControlled; } allGates = !allGates; } }
// Checks only signed, windowed point addition. // Others could be enabled public static void EstimateEllipticCurveArithmetic(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); System.IO.Directory.CreateDirectory(directory); // Loops over controlled/not and whether it counts all gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { var localControl = isControlled; var localGates = allGates; // Constant point addition is controlled, the others are not, // because in Shor's algorithm they do not need to be. // Thread nonWindowedThread = new Thread(() => BasicResourceTest<EllipticCurveConstantPointAdditionEstimator>( // EllipticCurveConstantPointAdditionEstimator.Run, // testSizes, // true, // directory + "Constant-point-addition", // localGates, // true)); // nonWindowedThread.Start(); // // Thread windowedThread = new Thread(() => BasicResourceTest<EllipticCurveWindowedPointAdditionEstimator>( // EllipticCurveWindowedPointAdditionEstimator.Run, // testSizes, // false, // directory + "Windowed-point-addition", // localGates, // true)); // windowedThread.Start(); // // Thread lowWidthThread = new Thread(() => BasicResourceTest<EllipticCurveWindowedPointAdditionLowWidthEstimator>( // EllipticCurveWindowedPointAdditionLowWidthEstimator.Run, // testSizes, // false, // directory + "Windowed-point-addition-low-width", // localGates, // true)); // lowWidthThread.Start(); Thread signedThread = new Thread(() => BasicResourceTest <EllipticCurveSignedWindowedPointAdditionEstimator>( EllipticCurveSignedWindowedPointAdditionEstimator.Run, testSizes, false, directory + "Windowed-point-addition-signed", localGates, true)); signedThread.Start(); // Thread fixedThread = new Thread(() => BasicResourceTest<FixedEllipticCurveSignedWindowedPointAdditionEstimator>( // FixedEllipticCurveSignedWindowedPointAdditionEstimator.Run, // testSizes, // false, // directory + "Fixed-modulus-signed", // localGates, // true)); // fixedThread.Start(); allGates = !allGates; } }
// "Expensive" modular operations, including square, multiplication, inversion // Does not check controlled vs. not controlled because the extra cost is so small, // and the operations are so costly to estimate. public static void EstimateExpensiveModularArithmetic(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); System.IO.Directory.CreateDirectory(directory); // Loops over controlled/not and whether it counts all gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { var localControl = isControlled; var localGates = allGates; Thread multiplyThread = new Thread(() => BasicResourceTest <MontgomeryMultiplicationEstimator>( MontgomeryMultiplicationEstimator.Run, testSizes, localControl, directory + "Modular-multiplication", localGates, true)); multiplyThread.Start(); // This is run as a comparison to the windowed version Thread multipyNoWindowsThread = new Thread(() => BasicResourceTest <NonWindowedMontgomeryMultiplicationEstimator>( NonWindowedMontgomeryMultiplicationEstimator.Run, testSizes, localControl, directory + "Modular-multiplication-no-windows", localGates, true)); multipyNoWindowsThread.Start(); Thread squareThread = new Thread(() => BasicResourceTest <MontgomerySquareEstimator>( MontgomerySquareEstimator.Run, testSizes, localControl, directory + "Modular-squaring", localGates, true)); squareThread.Start(); Thread invertThread = new Thread(() => BasicResourceTest <MontgomeryInversionEstimator>( MontgomeryInversionEstimator.Run, testSizes, localControl, directory + "Modular-Inversion", localGates, true)); invertThread.Start(); Thread divideThread = new Thread(() => BasicResourceTest <ModularDivisionEstimator>( ModularDivisionEstimator.Run, testSizes, localControl, directory + "Modular-division", localGates, true)); divideThread.Start(); allGates = !allGates; } }
public static void EstimateArithmetic(int[] testSizes, string directory) { // Writes global parameters (cost metric, testable gates) to terminal DriverParameters.Print(); System.IO.Directory.CreateDirectory(directory); // Loops over controlled/not and whether it counts all gates bool allGates = false; bool isControlled = false; for (int j = 0; j < 2; j++) { for (int i = 0; i < 2; i++) { // Creates a new thread for each operation being estimated var localControl = isControlled; var localGates = allGates; // Thread onesThread = new Thread(() => BasicResourceTest<CheckIfAllOneEstimator>( // CheckIfAllOneEstimator.Run, // testSizes, // localControl, // directory + "AllOnes", // localGates, // false)); // onesThread.Start(); Thread additionThread = new Thread(() => BasicResourceTest <AdditionEstimator>( AdditionEstimator.Run, testSizes, localControl, directory + "Addition", localGates, false)); additionThread.Start(); Thread additionNoCarryThread = new Thread(() => BasicResourceTest <AdditionNoCarryEstimator>( AdditionNoCarryEstimator.Run, testSizes, localControl, directory + "Addition-no-carry", localGates, false)); additionNoCarryThread.Start(); Thread constantAdditionThread = new Thread(() => BasicResourceTest <ConstantAdditionEstimator>( ConstantAdditionEstimator.Run, testSizes, localControl, directory + "Constant-addition", localGates, false)); constantAdditionThread.Start(); Thread greaterThanThread = new Thread(() => BasicResourceTest <GreaterThanEstimator>( GreaterThanEstimator.Run, testSizes, localControl, directory + "Greater-than", localGates, false)); greaterThanThread.Start(); isControlled = !isControlled; } allGates = !allGates; } }