arithsharing.h

Go to the documentation of this file.

#ifndef __ARITHSHARING_H__
#define __ARITHSHARING_H__

#include "sharing.h"
#include <algorithm>
#include "../circuit/arithmeticcircuits.h"

//#define DEBUGARITH
//#define VERIFY_ARITH_MT

template<typename T>
class ArithSharing: public Sharing {

public:
    ArithSharing(e_role role, uint32_t sharebitlen, ABYCircuit* circuit, crypto* crypt, e_mt_gen_alg mt_alg) :
            Sharing(role, sharebitlen, circuit, crypt) {
        m_eMTGenAlg = mt_alg;
        Init();
    }
    ;
    ~ArithSharing() {
        Reset();
    }
    ;

    //MEMBER FUNCTIONS OF THE SUPER CLASS
    void Reset();
    void PrepareSetupPhase(ABYSetup* setup);
    void PerformSetupPhase(ABYSetup* setup);
    void FinishSetupPhase(ABYSetup* setup);
    void EvaluateLocalOperations(uint32_t gateid);
    void EvaluateInteractiveOperations(uint32_t gateid);

    void FinishCircuitLayer();

    void PrepareOnlinePhase();

    void InstantiateGate(GATE* gate);
    void UsedGate(uint32_t gateid);

    void GetDataToSend(vector<BYTE*>& sendbuf, vector<uint32_t>& bytesize);
    void GetBuffersToReceive(vector<BYTE*>& rcvbuf, vector<uint32_t>& rcvbytes);

    uint32_t AssignInput(CBitVector& input);
    uint32_t GetOutput(CBitVector& out);

    uint32_t GetMaxCommunicationRounds() {
        return m_cArithCircuit->GetMaxDepth();
    }
    ;
    uint32_t GetNumNonLinearOperations() {
        return m_nMTs;
    }
    ;

    Circuit* GetCircuitBuildRoutine() {
        return m_cArithCircuit;
    }
    ;

    const char* sharing_type() {
        return "Arithmetic";
    }
    ;

    void PrintPerformanceStatistics();
    //ENDS HERE...
    void EvaluateSIMDGate(uint32_t gateid);

    void EvaluateINVGate(GATE* gate);
    void EvaluateCONVGate(GATE* gate);

private:

    ArithmeticCircuit* m_cArithCircuit;

    e_mt_gen_alg m_eMTGenAlg;

    uint32_t m_nMTs;
    uint32_t m_nNumCONVs;

    uint32_t m_nTypeBitLen;
    uint64_t m_nTypeBitMask;

    vector<uint32_t> m_vMTStartIdx;
    vector<uint32_t> m_vMTIdx;
    vector<GATE*> m_vMULGates;
    vector<GATE*> m_vInputShareGates;
    vector<GATE*> m_vOutputShareGates;
    vector<GATE*> m_vCONVGates;

    uint32_t m_nInputShareSndCtr;
    uint32_t m_nOutputShareSndCtr;

    uint32_t m_nInputShareRcvCtr;
    uint32_t m_nOutputShareRcvCtr;

    vector<CBitVector> m_vA; //Dim 1 for all pairs of sender / receiver, Dim 2 for MTs of different bitlengths as sender / receiver
    vector<CBitVector> m_vB; //value B of a multiplication triple
    vector<CBitVector> m_vS; // temporary value for the computation of the multiplication triples
    vector<CBitVector> m_vC; // value C of a multiplication triple
    vector<CBitVector> m_vD_snd; //Stores the D values (x ^ a) between an input and the multiplication value a
    vector<CBitVector> m_vE_snd; //Stores the E values (y ^ b) between the other input and the multiplication value b
    vector<CBitVector> m_vD_rcv;
    vector<CBitVector> m_vE_rcv;
    vector<CBitVector> m_vResA;
    vector<CBitVector> m_vResB;

    CBitVector m_vInputShareSndBuf;
    CBitVector m_vOutputShareSndBuf;

    CBitVector m_vInputShareRcvBuf;
    CBitVector m_vOutputShareRcvBuf;

    CBitVector m_vConvShareSndBuf;
    CBitVector m_vConvShareRcvBuf;

    vector<CBitVector> m_vConversionMasks;

    CBitVector m_vConversionRandomness;

    uint32_t m_nConvShareIdx; //the global
    uint32_t m_nConvShareSndCtr; //counts for each round
    uint32_t m_nConvShareRcvCtr;
    void ShareValues(GATE* gate);
    void ReconstructValue(GATE* gate);
    void AssignInputShares();
    void AssignOutputShares();

    void SelectiveOpen(GATE* gate);
    void EvaluateMTs();
    void EvaluateADDGate(GATE* gate);
    void EvaluateMULGate();

    void AssignConversionShares();

    void AssignServerConversionShares();

    void AssignClientConversionShares();

#ifdef VERIFY_ARITH_MT
    //called at setup -> finish
    void VerifyArithMT(ABYSetup* setup);
#endif

    void InitMTs();

    void ComputeMTsFromOTs();
    void FinishMTGeneration();
    void Init();
    void InitNewLayer();
};

#endif /* ArithSharing */