CONTENTS OF THIS FILE
---------------------

 * Introduction
 * Setting up the docker and running the experimental scripts
 * Running the code
 * Important Warning


INTRODUCTION
------------
 `/preprocessing` holds code for the 3-Party preprocessing phase
 `/2p-preprocessing` holds the OT-based code 2-Party preprocessing phase
 `/duoram-online` holds the code for online phase of the 3-Party Duoram and 2-Party writes. For 2-Party writes, switch off the `-ThreeParty` flag in the Makefile
 `/cpir-read`  includes the code CPIR-based reads


Setting up the docker and running the experimental scripts
----------------------------------------------------------
-    Go to the docker folder`cd Docker/`
-   `sh build-docker.sh` builds the docker image
-   `sh run-docker.sh` launches three docker containers for parties P2, P0, and P1
-   `sh set-networking.sh` sets up the latencies and bandwidth constraints among the three docker containers launched; pass arguments of latency and bandwidth 
-    For example `sh set-networking.sh 1ms  40mbit`. 
-   `sh unset-networking.sh` removes the latency and bandwidth settings.
-   `sh experiments.sh` runs the pre-processing phase of the 3-party computation.
-   `sh experiments-online.sh` runs the online phase of the 3-party computation.
-   `sh experiments-OT.sh` runs the OTs to generate blinds of 2-party preprocesing phase.
-   `sh experiments-2p-preproc.sh` runs the pre-processing phase of the 2-party computation.
-   `sh experiments-cpir.sh` runs the CPIR-based reads.
-   `sh cleanup.sh` stops the three dockers.

Running the code
-----------------

    1.  3-Party Prepreprocessing:
        Let ip0, ip1, and ip2 be the IP addresses of the three docker containers. Consider a database of size `2^N`. Suppose the goal is to generate `r` DPFs.
        The pre-processing generates DPFs with leaves of 128 bits. We use the first 64-bits for the writes. The remaining 64-bits are used for share conversion (XOR shared-flag vectors to additive shares)
         - `cd duoram/preprocessing & make`
         - `./p2preprocessing ip1 ip0 N r`
         - `./preprocessing1  ip2 ip0 N r`
         - `./preprocessing0  ip2 ip1 N r`
        
        This writes the evaluations of DPFs into a file which we use in the online phase.

        To run the preprocessing with debug flags set:
        -  `./debugp2preprocessing ip1 ip0 N r`
        -  `./debugpreprocessing1  ip2 ip0 N r`
        -  `./debugpreprocessing0  ip2 ip1 N r`


    2.  3-Party Online Phase:
         Let ip0, ip1, and ip2 be the IP addresses of the three docker containers. Consider a database of size `2^N`.  
         - `cd duoram/duoram-online & make`
         - `./p2      ip1 ip0 N W D I A` 
         - `./duoram1 ip0 ip2 N W D I A`
         - `./duoram0 ip1 ip2 N W D I A`

        To run the online phase with debug flags set:
        - `./debugp2 ip1 ip0 N r`
        - `./debugduoram1  ip2 ip0 N r`
        - `./debugduoram1  ip2 ip1 N r`

    3. 2-Party Preprocessing:
        Let ip0 and ip1 be the IP addresses of the two docker containers. To generate `W` blinding factors:
         - `cd duoram/2p-preprocessing & make`
         - `./OT ip0 ip1 1 128*W
         - `./OT ip0 ip1 1 128*W
         - `./preprocessing1  ip0 N r`
         - `./preprocessing0  ip1 N r`
    
    4. 2-Party Read:
         - `cd duoram/cpir-read/cxx & make`
         - ./spir_test1 ip0 N threads npreproc queries 
         - ./spir_test0 ip1 N threads npreproc queries 

 Important Warning
 --------------------
This software is for performance testing ONLY! The purpose of this software is to evaluate the performance of the system, NOT to be used in a deployment scenario. The software is full of security vulnerabilities. 

 

 