insert heap

heap.cpp

@@ -9,11 +9,11 @@
  
 void HEAP::initialize(int num_players, size_t size) {
     this->MAX_SIZE = size;
-    this->num_items = size;
+    this->num_items = 0;
     oram = new Duoram<RegAS>(num_players, size);
 }
 
-void reconstruct_AS(MPCTIO &tio, yield_t &yield, RegAS AS) {
+RegAS reconstruct_AS(MPCTIO &tio, yield_t &yield, RegAS AS) {
     RegAS peer_AS;
     RegAS reconstructed_AS = AS;
     if (tio.player() == 1) {
@@ -34,14 +34,13 @@ void reconstruct_AS(MPCTIO &tio, yield_t &yield, RegAS AS) {
         reconstructed_AS += peer_AS;
     }
     
-   printf("reconstructed_AS = ");
-   reconstructed_AS.dump();
-   printf("\n\n");
+ 
+   return reconstructed_AS;
 }
 
 bool reconstruct_flag(MPCTIO &tio, yield_t &yield, RegBS flag) {
     RegBS peer_flag;
-    RegBS reconstructed_flag;
+    RegBS reconstructed_flag = flag;
     if (tio.player() == 1) {
         tio.queue_peer(&flag, sizeof(flag));
     } else {
@@ -50,6 +49,8 @@ bool reconstruct_flag(MPCTIO &tio, yield_t &yield, RegBS flag) {
         reconstructed_flag ^= peer_flag;
     }
 
+    yield();
+
     if (tio.player() == 0) {
         tio.queue_peer(&flag, sizeof(flag));
     } else {
@@ -61,42 +62,147 @@ bool reconstruct_flag(MPCTIO &tio, yield_t &yield, RegBS flag) {
     return reconstructed_flag.bshare;
 }
 
-int HEAP::insert(MPCTIO tio, yield_t &yield, std::vector<RegAS>& A, RegAS val) {
-
-    auto HeapArray = oram->flat(tio, yield);
-    num_items++;
-    //auto A = oram->flat(tio, yield);
-    std::cout << "num_items = " << num_items << std::endl;
- 
-    val.randomize();
-    size_t child  = num_items-1;
-    size_t parent = child/2;
-    std::cout << "child = " << child << std::endl;
-    HeapArray[num_items] = val;
-    while(parent != 0)
-    {
-     CDPF cdpf = tio.cdpf(yield);
- 
-     auto [lt, eq, gt] = cdpf.compare(tio, yield, A[child]-A[parent], tio.aes_ops());   
-     std::cout << "child = " << child << std::endl;
- 
-     
-
-     mpc_oswap(tio, yield, A[child], A[parent], lt, 64);
- 
- 
-     child = parent;
-     parent = parent/2;
+int HEAP::insert(MPCTIO tio, yield_t &yield, RegAS val) {
+  auto HeapArray = oram->flat(tio, yield);
+  num_items++;
+  std::cout << "num_items = " << num_items << std::endl;
+  val.randomize();
+  val.ashare = val.ashare/1000;
+  std::cout << "we are adding in: " << std::endl;
+  reconstruct_AS(tio, yield, val);
+  yield();
+  size_t child  = num_items;
+  size_t parent = child/2;
+  std::cout << "child = " << child << std::endl;
+  std::cout << "parent = " << parent << std::endl;
+  HeapArray[num_items] = val;
+  RegAS tmp = HeapArray[num_items];
+  reconstruct_AS(tio, yield, tmp);
+  yield();
+  while(parent != 0) {
+    std::cout << "while loop\n";
+    RegAS sharechild  = HeapArray[child];
+    RegAS shareparent = HeapArray[parent];
+    RegAS sharechildrec = reconstruct_AS(tio, yield, sharechild);
+    yield();
+    RegAS shareparentrec = reconstruct_AS(tio, yield, shareparent);
+    yield();
+    std::cout << "\nchild reconstruct_AS = \n";
+    sharechildrec.dump();
+    std::cout << "\nparent reconstruct_AS = \n";
+    shareparentrec.dump();
+    std::cout << "\n----\n";
+    CDPF cdpf = tio.cdpf(yield);
+    RegAS diff =  sharechild-shareparent;
+    std::cout << "diff = " << std::endl;
+    RegAS diff_rec = reconstruct_AS(tio, yield, diff);
+    diff_rec.dump();
+    std::cout << std::endl << std::endl;
+    auto [lt, eq, gt] = cdpf.compare(tio, yield, diff, tio.aes_ops());
+    auto lteq = lt ^ eq;
+    bool lteq_rec = reconstruct_flag(tio, yield, lteq);
+    yield();   
+    bool lt_rec = reconstruct_flag(tio, yield, lt);
+    yield();
+    std::cout <<"lt_rec = " << (int) lt_rec << std::endl;
+    std::cout << std::endl;
+    bool eq_rec = reconstruct_flag(tio, yield, eq);
+    yield();
+    std::cout <<"eq_rec = " << (int) eq_rec << std::endl;
+    std::cout << std::endl;
+    yield();   
+    bool gt_rec = reconstruct_flag(tio, yield, gt);
+    yield();
+    std::cout <<"gt_rec = " << (int) gt_rec << std::endl;
+    std::cout << std::endl;
+    if(lteq_rec) {
+      if(sharechildrec.ashare > shareparentrec.ashare) {
+        std::cout << "\nchild reconstruct_AS = \n";
+        sharechildrec.dump();
+        std::cout << "\nchild reconstruct_AS = \n";
+        shareparentrec.dump();
+        std::cout << "\n----\n";
+      }
+      assert(sharechildrec.ashare <= shareparentrec.ashare);
+    }
+    if(gt_rec) {
+      if(sharechildrec.ashare < shareparentrec.ashare) {
+        std::cout << "\nchild reconstruct_AS = \n";
+        sharechildrec.dump();
+        std::cout << "\nchild reconstruct_AS = \n";
+        shareparentrec.dump();
+        std::cout << "\n----\n";
+      }
+        assert(sharechildrec.ashare > shareparentrec.ashare);
+      }
+
+      std::cout << "child = " << child << std::endl;
+      sharechildrec  =  reconstruct_AS(tio, yield, sharechild);
+      sharechildrec.dump();
+      yield();
+      std::cout << "parent = " << parent << std::endl;
+      shareparentrec =  reconstruct_AS(tio, yield, shareparent);
+      shareparentrec.dump();
+      yield();
+
+      std::cout << "\n^^^ before mpc_oswap\n";
+      mpc_oswap(tio, yield, sharechild, shareparent, lt, 64);
+
+      HeapArray[child]       = sharechild;
+      HeapArray[parent]      = shareparent;
+
+      std::cout << "child = " << child << std::endl;
+      sharechildrec  =  reconstruct_AS(tio, yield, sharechild);
+      sharechildrec.dump();
+      yield();
+      std::cout << "parent = " << parent << std::endl;
+      shareparentrec =  reconstruct_AS(tio, yield, shareparent);
+      shareparentrec.dump();
+      yield();
+      std::cout << "\n^^^after mpc_oswap\n";
+      assert(sharechildrec.ashare >= shareparentrec.ashare);
+
+      std::cout << "we asserted that: \n";
+      sharechildrec.dump();
+      std::cout << std::endl << " < " << std::endl;
+      shareparentrec.dump();
+      std::cout << "\n ----- \n";
+
+      child = parent;
+      parent = child/2;
     }
+
     return 1;
 }
 
-int HEAP::verify_heap_property(MPCTIO tio, yield_t &yield, std::vector<RegAS> A) {
+int HEAP::verify_heap_property(MPCTIO tio, yield_t &yield) {
 
-for(size_t i = 0; i < num_items; ++i)
-{
+std::cout << std::endl << std::endl << "verify_heap_property \n\n\n";
+auto HeapArray = oram->flat(tio, yield);
+ 
+    RegAS heapreconstruction[num_items];
+    for(size_t j = 0; j <= num_items; ++j)
+    {
+        RegAS tmp = HeapArray[j];
+        heapreconstruction[j] = reconstruct_AS(tio, yield, tmp);
+        yield();
+    }
 
-}
+    for(size_t j = 1; j < num_items/2; ++j)
+    {
+        if(heapreconstruction[j].ashare > heapreconstruction[2*j].ashare)
+        {
+            std::cout << "j = " << j << std::endl;
+            heapreconstruction[j].dump();
+            std::cout << std::endl;
+            std::cout << "2*j = " << 2*j << std::endl;
+            heapreconstruction[2*j].dump();
+            std::cout << std::endl;
+
+        }
+        assert(heapreconstruction[j].ashare <= heapreconstruction[2*j].ashare);
+    }
+ 
 
 return 1;
 }
@@ -124,57 +230,57 @@ void restore_heap_property(MPCTIO tio, yield_t &yield, RegAS& parent, RegAS& lef
   rightchild = (sum - smallerchild - smallest);
 }
 
-RegAS HEAP::extract_min(MPCTIO tio, yield_t &yield, std::vector<RegAS> A) {
-    // this->MAX_SIZE = size;
-    // oram = new Duoram<RegXS>(num_players, size);
-    std::cout << "extract_min" << std::endl;
-    std::cout << "num_items = " << num_items << std::endl;
-    // if(num_items==0)
-    //     return RegAS(0);
+// RegAS HEAP::extract_min(MPCTIO tio, yield_t &yield) {
+//     // this->MAX_SIZE = size;
+//     // oram = new Duoram<RegXS>(num_players, size);
+//     std::cout << "extract_min" << std::endl;
+//     std::cout << "num_items = " << num_items << std::endl;
+//     // if(num_items==0)
+//     //     return RegAS(0);
     
 
-    restore_heap_property(tio, yield, A[0], A[1], A[2]);
-    RegAS minval = A[1];    
-    //A[1] = A[num_items-1];
-    //if(num_items!=0) 
-    {
-        //Delete root
+// //    restore_heap_property(tio, yield, A[0], A[1], A[2]);
+//     //RegAS minval = A[1];    
+//     //A[1] = A[num_items-1];
+//     //if(num_items!=0) 
+//     {
+//         //Delete root
 
-        //Node zero;
-        // for(size_t j = 0; j < num_items; ++j)   
-        // {
-        //     RegAS val;
-        //     val.set((0+j)*tio.player());
-        //     A[j] = val;
-        // }
+//         //Node zero;
+//         // for(size_t j = 0; j < num_items; ++j)   
+//         // {
+//         //     RegAS val;
+//         //     val.set((0+j)*tio.player());
+//         //     A[j] = val;
+//         // }
 
-       // num_items--;
+//        // num_items--;
 
-     //    CDPF cdpf = tio.cdpf(yield);
-     //    RegAS tmp = A[10];
-     //    RegAS tmp1 = A[12];
+//      //    CDPF cdpf = tio.cdpf(yield);
+//      //    RegAS tmp = A[10];
+//      //    RegAS tmp1 = A[12];
 
-     //    auto [lt, eq, gt] = cdpf.compare(tio, yield, tmp-tmp1, tio.aes_ops());    
+//      //    auto [lt, eq, gt] = cdpf.compare(tio, yield, tmp-tmp1, tio.aes_ops());    
     
-     // //   reconstruct_flag(tio, yield, lt);
-     //    RegAS selected_val;
-     //    mpc_select(tio, yield, selected_val, gt, tmp, tmp1, 64);
+//      // //   reconstruct_flag(tio, yield, lt);
+//      //    RegAS selected_val;
+//      //    mpc_select(tio, yield, selected_val, gt, tmp, tmp1, 64);
 
-     //    printf("selected_val is: \n");
-     //    reconstruct_AS(tio, yield, selected_val);
+//      //    printf("selected_val is: \n");
+//      //    reconstruct_AS(tio, yield, selected_val);
        
-     //    yield();
-     //    printf("first option is: \n");
-     //    reconstruct_AS(tio, yield, tmp);
-     //    yield();
-     //    printf("second option is: \n");
-     //    reconstruct_AS(tio, yield, tmp1);
+//      //    yield();
+//      //    printf("first option is: \n");
+//      //    reconstruct_AS(tio, yield, tmp);
+//      //    yield();
+//      //    printf("second option is: \n");
+//      //    reconstruct_AS(tio, yield, tmp1);
  
 
-        //return 1; 
-    } 
-     return minval;
-}
+//         //return 1; 
+//     } 
+//      return 1;
+// }
  void Heap(MPCIO &mpcio, const PRACOptions &opts, char **args)
 {
 
@@ -202,41 +308,20 @@ RegAS HEAP::extract_min(MPCTIO tio, yield_t &yield, std::vector<RegAS> A) {
         
 
 
-        std::vector<RegAS> HeapArray;
-        HeapArray.resize(size);
-        for(size_t i = 0; i < size; ++i)
-        {
-          HeapArray[i].dump();
-          std::cout << std::endl;  
-        }
-
+ 
         HEAP tree(tio.player(), size);
-        for(size_t i = 0; i < HeapArray.size(); ++i)
-        {
-          std::cout << i << " : \n";
-          HeapArray[i].dump();
-          std::cout << std::endl;  
-        }
-
-        std::cout << "\n--------\n\n";
+ 
         
-        for(size_t j = 0; j < 10; ++j)
+        for(size_t j = 0; j < 100; ++j)
         {
          RegAS inserted_val;
-         tree.insert(tio, yield, HeapArray, inserted_val);
+         tree.insert(tio, yield, inserted_val);
+         tree.verify_heap_property(tio, yield);
         }
 
-        std::cout << "\n--------\n\n";
-
-        for(size_t i = 0; i < HeapArray.size(); ++i)
-        {
-          std::cout << i << " : \n";
-          reconstruct_AS(tio, yield, HeapArray[i]);
-          yield();
-          std::cout << std::endl;  
-        }
+     
       
-         tree.extract_min(tio, yield, HeapArray);
-        // tree.verify_heap_property(tio, yield, HeapArray);
+         //tree.extract_min(tio, yield);
+        
     });
 }

heap.hpp

@@ -36,9 +36,9 @@ class HEAP {
     };
 
     void initialize(int num_players, size_t size);
-    RegAS extract_min(MPCTIO tio, yield_t &yield, std::vector<RegAS> A);
-    int insert(MPCTIO tio, yield_t &yield, std::vector<RegAS>& A, RegAS val);
-    int verify_heap_property(MPCTIO tio, yield_t &yield, std::vector<RegAS> A);
+    RegAS extract_min(MPCTIO tio, yield_t &yield);
+    int insert(MPCTIO tio, yield_t &yield, RegAS val);
+    int verify_heap_property(MPCTIO tio, yield_t &yield);
 
     // void insert(MPCTIO &tio, yield_t &yield, Node &node);
     // int del(MPCTIO &tio, yield_t &yield, RegAS del_key);