percyserver.h

// Percy++ Copyright 2007,2012,2013,2014
// Ian Goldberg <iang@cs.uwaterloo.ca>,
// Casey Devet <cjdevet@uwaterloo.ca>,
// Paul Hendry <pshendry@uwaterloo.ca>,
// Wouter Lueks <wouter@telox.net>,
// 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 __PERCYSERVER_H__
#define __PERCYSERVER_H__

#include <iostream>
#include "datastore.h"
#include "percyparams.h"
#include "percystats.h"
#include "streams.h"

class PercyServer {
public:
    virtual ~PercyServer();

    static PercyServer * make_server (DataStore * datastore, 
        const PercyServerParams * params, PercyStats * stats = NULL);

    void be_byzantine ();

    static const nqueries_t STRASSEN_OPTIMAL = -1;

    void set_strassen_max_depth(nqueries_t depth);

    nqueries_t get_strassen_max_depth();

    virtual bool handle_request (std::istream &is, std::ostream &os,
                 const std::vector<std::iostream*> &workers =
                    std::vector<std::iostream*>());

    virtual bool handle_request (const std::vector<std::istream *> &isv,
                 const std::vector<std::ostream *> &osv,
                 const std::vector<std::iostream*> &workers =
                    std::vector<std::iostream*>());

protected:
    friend class RecursiveServer;
    friend void * thread_work (void * arg);

    virtual bool handle_request_impl (
        const std::vector<unsigned char*> &requests,
        const std::vector<unsigned char*> &responses) = 0;

    virtual bool handle_request_distributed (
        const std::vector<unsigned char*> &requests,
        const std::vector<unsigned char*> &responses,
        const std::vector<std::iostream*> &workers);

    virtual bool handle_request_threaded (
        const std::vector<unsigned char*> &requests,
        const std::vector<unsigned char*> &responses);

    virtual void combine_results (unsigned char * result, 
        const std::vector<unsigned char*> &worker_results) = 0;

    PercyServer (DataStore * datastore, const PercyServerParams * serverparams,
        PercyStats * stats = NULL);

    bool byzantine;
    DataStore * datastore;
    const PercyServerParams * serverparams;
    PercyStats * stats;
    nqueries_t strassen_max_depth;
    nqueries_t strassen_level_reached;
    std::vector<PercyServer*> subservers;

    // Lightweight matrix implementation
    template <typename GF2E_Element> class Matrix;
    template <typename GF2E_Element> class SubMatrix;
    template <typename GF2E_Element> class Col;
    template <typename GF2E_Element> class Row;
    template <typename GF2E_Element> class Elem;

    template <typename GF2E_Element_>
    friend std::ostream &operator<<(std::ostream &os,
                const Matrix<GF2E_Element_> &m);
    template <typename GF2E_Element_>
    friend std::ostream &operator<<(std::ostream &os,
                const SubMatrix<GF2E_Element_> &m);
};

std::vector<nqueries_t> split_queries (nqueries_t num_queries, 
    nservers_t num_workers);

#include "gf2e_matrix.h"

#endif