percyparams.h

Go to the documentation of this file.

// Percy++ Copyright 2007,2012,2013,2014
// Ian Goldberg <iang@cs.uwaterloo.ca>,
// Casey Devet <cjdevet@uwaterloo.ca>,
// Paul Hendry <pshendry@uwaterloo.ca>,
// Ryan Henry <rhenry@cs.uwaterloo.ca>
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of version 2 of the GNU General Public License as
// published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// There is a copy of the GNU General Public License in the COPYING file
// packaged with this plugin; if you cannot find it, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301 USA

#ifndef __PERCYPARAMS_H__
#define __PERCYPARAMS_H__

#include <iostream>
#include <vector>
#include <utility>
#include "version.h"
#include "percytypes.h"

/******************************************************************************
  ENUMERATED TYPES AND TYPEDEFS
******************************************************************************/

enum PercyMode {
    MODE_NONE = 0,
    MODE_ZZ_P,      
    MODE_GF28,      
    MODE_GF216,     
    MODE_CHOR,      
    MODE_AG,        
    MODE_RECURSIVE_AG,  
    MODE_HYBRID     
};

extern const char * PercyModeStrings[];

extern std::ostream& operator<< (std::ostream &os, PercyMode mode);

enum DistSplit {
    DIST_SPLIT_QUERIES,     
    DIST_SPLIT_RECORDS,     
    DIST_SPLIT_RECORD_BYTES 
};

extern const char * DistSplitStrings[];

extern std::ostream& operator<< (std::ostream &os, DistSplit mode);

typedef std::pair<dbsize_t, dbsize_t> Dimension;


/******************************************************************************
  CLASS DEFINITIONS
******************************************************************************/


class PercyParams {
public:
    PercyParams (dbsize_t num_blocks, dbsize_t block_size, dbsize_t word_size,
        PercyMode mode, nservers_t tau = 0, 
        dbsize_t virtual_block_size = 1);

    virtual ~PercyParams () {}

    // Access parameters
    dbsize_t num_blocks () const { return _num_blocks; }
    dbsize_t block_size () const { return _block_size; }
    virtual dbsize_t server_block_size () const { return _block_size; }
    dbsize_t word_size () const { return _word_size; }
    dbsize_t words_per_block () const { return _words_per_block; }
    PercyMode get_mode () const { return mode; }
    nservers_t tau () const { return _tau; }
    dbsize_t num_virtual_blocks () const { return _num_virtual_blocks; }
    dbsize_t virtual_block_size () const { return _virtual_block_size; }

    virtual dbsize_t request_size (nqueries_t num_queries = 1) const = 0;
    virtual dbsize_t response_size (nqueries_t num_queries = 1) const = 0;

    void print (std::ostream& os) const;

    virtual void print_mode_specific (std::ostream& os) const {}

    virtual void write (std::ostream &os) const;

    virtual bool check_compatible (std::istream &is) const;

    virtual std::vector<const PercyParams*> create_worker_params (
        std::vector<Dimension> worker_dims) const = 0;

    virtual bool is_recursive () const { return false; }

protected:
    unsigned char version[3];
    dbsize_t _num_blocks;
    dbsize_t _block_size;
    dbsize_t _word_size;
    dbsize_t _words_per_block;
    PercyMode mode;
    nservers_t _tau;
    dbsize_t _num_virtual_blocks;
    dbsize_t _virtual_block_size;
};



class PercyClientParams {
public:
    PercyClientParams (const PercyParams * params, nservers_t num_servers = 1, 
        bool is_null = false);

    virtual ~PercyClientParams () {};

    void send (std::ostream &os, nservers_t sid) const;

    bool is_compatible (std::istream &is, nservers_t sid) const;

    // Access parameters
    nservers_t num_servers () const { return _num_servers; }

    void print (std::ostream& os) const;

    const PercyParams * percy_params () const { return params; }

    bool is_null () const { return null; }

protected:
    const PercyParams * params;

    nservers_t _num_servers;
    bool null;
};


struct serverinfo {
    nservers_t sid; 
    char * addr;    
    uint16_t port;  
};

class PercyServerParams {
public:
    PercyServerParams (const PercyParams * params, nservers_t sid,
        bool be_byzantine = false);

    PercyServerParams (const PercyParams * params, nservers_t sid,
        nservers_t num_threads = 0, DistSplit tsplit = DIST_SPLIT_RECORDS,
        nservers_t num_workers = 0, DistSplit wsplit = DIST_SPLIT_RECORDS,
        std::vector<nservers_t> worker_sids = std::vector<nservers_t>(),
        bool fork = false, bool be_byzantine = false);

    virtual ~PercyServerParams ();

    void send (std::ostream &os, bool to_worker = false) const;

    bool is_compatible (std::istream &is) const;

    bool is_recursive () const { return params->is_recursive(); }

    // Access parameters
    nservers_t get_sid () const { return sid; }
    bool is_byzantine () const { return be_byzantine; }

    bool is_threaded () const {
    return (_num_workers == 0 && _num_threads > 0);
    }
    nservers_t num_threads () const { return _num_threads; }
    DistSplit thread_split () const { return tsplit; }
    bool use_forked_threads () const { return is_forked; }

    bool is_distributed () const { 
    return _num_workers > 0; 
    }
    nservers_t num_workers () const { return _num_workers; }
    DistSplit worker_split () const { return wsplit; }

    const PercyParams * get_worker_params (nservers_t wid) const {
    return (wid < worker_params.size() ? worker_params[wid] : NULL);
    }
    std::vector<const PercyParams*> get_all_worker_params () const {
    return worker_params;
    }

    const PercyServerParams * get_worker_serverparams (nservers_t wid) const {
    return (wid < worker_serverparams.size() ? worker_serverparams[wid] : NULL);
    }
    std::vector<const PercyServerParams*> get_all_worker_serverparams () const {
    return worker_serverparams;
    }

    const PercyParams * get_thread_params (nservers_t wid) const {
    return (wid < thread_params.size() ? thread_params[wid] : NULL);
    }
    std::vector<const PercyParams*> get_all_thread_params () const {
    return thread_params;
    }

    const PercyServerParams * get_thread_serverparams (nservers_t wid) const {
    return (wid < thread_serverparams.size() ? thread_serverparams[wid] : NULL);
    }
    std::vector<const PercyServerParams*> get_all_thread_serverparams () const {
    return thread_serverparams;
    }

    void print (std::ostream& os) const;

    virtual void print_distributed (std::ostream& os) const;

    const PercyParams * percy_params () const { return params; }

protected:
    const PercyParams * params;

    nservers_t sid;
    bool be_byzantine;

    // Distributed members
    nservers_t _num_threads;
    DistSplit tsplit;
    bool is_forked;
    nservers_t _num_workers;
    DistSplit wsplit;

    std::vector<const PercyParams*> worker_params;
    std::vector<const PercyServerParams*> worker_serverparams;

    std::vector<const PercyParams*> thread_params;
    std::vector<const PercyServerParams*> thread_serverparams;
};

#endif