Pre computations (#259)

* This is the first step of the implementation to use precomputed values to encrypt a ballot. There is are two queues in a global (PrecomputedBufferContext) and the queues are populated with a populate method and stopped with a stop_populate method. Then in encryptSelection (encrypt.cpp) if precomputed values are available in the queues then those values are used to generate the encrypted selection.

* More changes for precomputed values.

* Add testing for the precompute buffers change.

* Add benchmarking tests for the new precomputed values APIs.

* Update to the benchmarking tests.

* Clean up missing xml documentation for exceptions

* precompute integration

* Making sure calling stop_populate after calling populate in tests.

* Fix issue with setting of max queue size.

* fixing integration

* Remove the dependency on async.hpp.

* Updated the code to fix a number of issues pointed out during PR review.

* Satisfy rule of 5

* Remove the TripleEntry and QuadrupleEntry objects and store the Triple and Quadruple entries in the queue.

* Removed sleeps in test code and in the PrecomputeAPI.

* add lock_guards to the precompute

* created const for default precompute buffer size.

* adding resend for completed events

* Moved the assert to the bottom of the tests to get the rest of the results checked first

* Adding an init method to the PrecomputeBufferContext.

* Created new init function to have the api call to know when it is ready.

* updating version number for nuget

Co-authored-by: Jeff <spelmaa@wwu.edu>
Co-authored-by: SteveMaier-IRT <steve.maier@infernored.com>

Author: 3 people

bindings/netstandard/ElectionGuard/ElectionGuard.Encryption.Tests/TestPrecompute.cs

@@ -11,6 +11,11 @@ namespace ElectionGuard.Encryption.Tests
     [TestFixture]
     class TestPrecompute
     {
+        readonly int MAX_COMPLETE_DELAY = 7000;
+        readonly int SMALL_BUFFER_SIZE = 10;
+        readonly int DEFAULT_BUFFER_SIZE = 5000;
+        readonly int LARGE_BUFFER_SIZE = 6000;
+
         [Test]
         public void Test_Precompute_Status_NoStarted()
         {
@@ -24,31 +29,94 @@ public void Test_Precompute_Status_NoStarted()
         [Test]
         public void Test_Precompute_Status_Running()
         {
+            var waitHandle = new AutoResetEvent(false);
+
             Precompute precompute = new Precompute();
+            var keypair = ElGamalKeyPair.FromSecret(Constants.TWO_MOD_Q);
+
+            precompute.CompletedEvent += (PrecomputeStatus completedStatus) =>
+            {
+                Assert.AreEqual(PrecomputeState.UserStopped, completedStatus.CurrentState);
+                waitHandle.Set();
+            };
+            precompute.StartPrecomputeAsync(keypair.PublicKey, LARGE_BUFFER_SIZE);
+            var runningStatus = precompute.GetStatus();
+            precompute.StopPrecompute();
 
-            CancellationTokenSource cts = new CancellationTokenSource();
+            var waitReturn = waitHandle.WaitOne(MAX_COMPLETE_DELAY);
 
-            precompute.StartPrecomputeAsync(1, cts.Token);
+            int count = -1;
+            int queue_size = -1;
+            precompute.GetProgress(out count, out queue_size);
             var status = precompute.GetStatus();
-            precompute.StopPrecompute();
 
-            Assert.AreEqual(PrecomputeState.Running, status.CurrentState);
+            Assert.AreEqual(LARGE_BUFFER_SIZE, queue_size);
+            Assert.AreEqual(PrecomputeState.Running, runningStatus.CurrentState);
+            Assert.AreEqual(true, waitReturn);
         }
 
         [Test]
         public void Test_Precompute_Status_Stopped()
         {
-            Precompute precompute = new Precompute();
+            var waitHandle = new AutoResetEvent(false);
 
-            CancellationTokenSource cts = new CancellationTokenSource();
+            Precompute precompute = new Precompute();
+            var keypair = ElGamalKeyPair.FromSecret(Constants.TWO_MOD_Q);
 
-            precompute.StartPrecomputeAsync(1, cts.Token);
+            precompute.CompletedEvent += (PrecomputeStatus completedStatus) =>
+            {
+                Assert.AreEqual(PrecomputeState.UserStopped, completedStatus.CurrentState);
+                waitHandle.Set();
+            };
+            precompute.StartPrecomputeAsync(keypair.PublicKey);
+            var statusRunning = precompute.GetStatus();
             precompute.StopPrecompute();
-            Thread.Sleep(1000);
 
+            var waitReturn = waitHandle.WaitOne(MAX_COMPLETE_DELAY);
+
+            int count = -1;
+            int queue_size = -1;
+            precompute.GetProgress(out count, out queue_size);
             var status = precompute.GetStatus();
 
+            Assert.AreEqual(DEFAULT_BUFFER_SIZE, queue_size);
+            Assert.AreNotEqual(-1, count);
+
+            Assert.AreEqual(PrecomputeState.Running, statusRunning.CurrentState);
             Assert.AreEqual(PrecomputeState.UserStopped, status.CurrentState);
+
+            Assert.AreEqual(true, waitReturn);
+        }
+
+        [Test]
+        public void Test_Precompute_Status_Complete()
+        {
+            var waitHandle = new AutoResetEvent(false);
+
+            Precompute precompute = new Precompute();
+            var keypair = ElGamalKeyPair.FromSecret(Constants.TWO_MOD_Q);
+
+            precompute.CompletedEvent += (PrecomputeStatus completedStatus) =>
+            {
+                Assert.AreEqual(SMALL_BUFFER_SIZE, completedStatus.CompletedExponentiationsCount);
+                Assert.AreEqual(1.0, completedStatus.Percentage);
+                Assert.AreEqual(PrecomputeState.Completed, completedStatus.CurrentState);
+                waitHandle.Set();
+            };
+            precompute.StartPrecomputeAsync(keypair.PublicKey, SMALL_BUFFER_SIZE);
+
+            var waitReturn = waitHandle.WaitOne(MAX_COMPLETE_DELAY);
+
+            int count = -1;
+            int queue_size = -1;
+            precompute.GetProgress(out count, out queue_size);
+            var status = precompute.GetStatus();
+
+            Assert.AreEqual(SMALL_BUFFER_SIZE, queue_size);
+            Assert.AreEqual(SMALL_BUFFER_SIZE, count);
+
+            Assert.AreEqual(PrecomputeState.Completed, status.CurrentState);
+            Assert.AreEqual(true, waitReturn);
         }
 
     }

bindings/netstandard/ElectionGuard/ElectionGuard.Encryption/ElectionGuard.Encryption.csproj

@@ -7,9 +7,9 @@
     <!-- Project -->
     <RootNamespace>ElectionGuard</RootNamespace>
     <AssemblyName>ElectionGuard.Encryption</AssemblyName>
-    <Version>0.1.8</Version>
-    <AssemblyVersion>0.1.8.0</AssemblyVersion>
-    <AssemblyFileVersion>0.1.8.0</AssemblyFileVersion>
+    <Version>0.1.9</Version>
+    <AssemblyVersion>0.1.9.0</AssemblyVersion>
+    <AssemblyFileVersion>0.1.9.0</AssemblyFileVersion>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -19,7 +19,7 @@
     <Title>ElectionGuard Encryption</Title>
     <Description>Open source implementation of ElectionGuard's ballot encryption.</Description>
     <Authors>Microsoft</Authors>
-    <PackageVersion>0.1.8</PackageVersion>
+    <PackageVersion>0.1.9</PackageVersion>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/microsoft/electionguard-cpp</PackageProjectUrl>
     <RepositoryUrl>https://github.com/microsoft/electionguard-cpp</RepositoryUrl>

bindings/netstandard/ElectionGuard/ElectionGuard.Encryption/ElectionGuardException.cs

@@ -7,14 +7,40 @@ namespace ElectionGuard
     /// </summary>
     public class ElectionGuardException : Exception
     {
+        /// <summary>
+        /// Property for the status code of the exception
+        /// </summary>
         public Status Status { get; set; }
 
+        /// <summary>
+        /// Default constructor
+        /// </summary>
         public ElectionGuardException() { }
+
+        /// <summary>
+        /// Parameterized constructor that sets the message
+        /// </summary>
+        /// <param name="message">message to be used in the exception handling</param>
+        /// <returns>New ElectionGuardException object</returns>
         public ElectionGuardException(string message) : base(message) { }
+
+        /// <summary>
+        /// Parameterized constructor that sets the message and the error code
+        /// </summary>
+        /// <param name="message">message to be used in the exception handling</param>
+        /// <param name="code">error code to identify the exception</param>
+        /// <returns>New ElectionGuardException object</returns>
         public ElectionGuardException(string message, Status code) : base(message)
         {
             this.Status = code;
         }
+
+        /// <summary>
+        /// Parameterized constructor that uses another exception and wraps it
+        /// </summary>
+        /// <param name="message">message to be used in the exception handling</param>
+        /// <param name="inner">exception to wrap inside the ElectionGuardException</param>
+        /// <returns>New ElectionGuardException object</returns>
         public ElectionGuardException(string message, System.Exception inner) : base(message, inner) { }
     }