snab_base.hpp

Go to the documentation of this file.

/*
 *  SNABSuite - Spiking Neural Architecture Benchmark Suite
 *  Copyright (C) 2016  Christoph Jenzen
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef SNABSUITE_COMMON_SNAB_BASE_HPP
#define SNABSUITE_COMMON_SNAB_BASE_HPP

#include <cypress/cypress.hpp>
#include <string>

namespace SNAB {
class SNABBase {
public:
    SNABBase(std::string name, std::string backend,
             std::initializer_list<std::string> indicator_names,
             std::initializer_list<std::string> indicator_types,
             std::initializer_list<std::string> indicator_measures,
             std::initializer_list<std::string> indicator_units,
             std::initializer_list<std::string> required_parameters,
             size_t bench_index);

    virtual cypress::Network &build_netw(cypress::Network &network) = 0;

    cypress::Network &build() { return build_netw(m_netw); };

    virtual void run_netw(cypress::Network &network) = 0;

    void run() { run_netw(m_netw); };

    const std::string snab_name() const { return m_snab_name; }

    const std::vector<std::string> &indicator_names() const
    {
        return m_indicator_names;
    }

    const std::vector<std::string> &indicator_types() const
    {
        return m_indicator_types;
    }

    const std::vector<std::string> &indicator_measures() const
    {
        return m_indicator_measures;
    }

    virtual std::vector<std::array<cypress::Real, 4>> evaluate() = 0;

    cypress::Json evaluate_json();

    cypress::Json get_config() const { return m_config_file; }

    void set_config(cypress::Json json) { m_config_file = json; }

    void reset_network() { m_netw = cypress::Network(); }

    bool valid() const { return m_valid; }

    virtual std::shared_ptr<SNABBase> clone() = 0;

    virtual ~SNABBase() {}

protected:
    cypress::Network m_netw;

    cypress::Json m_config_file;

    std::string m_backend;

    bool m_valid = false;

    const std::string m_snab_name;

    const std::vector<std::string> m_indicator_names;

    const std::vector<std::string> m_indicator_types;

    const std::vector<std::string> m_indicator_measures;

    const std::vector<std::string> m_indicator_units;

    std::string _debug_filename(const std::string append = std::string()) const;

    const size_t m_bench_index;
};

cypress::Real NaN();
}  // namespace SNAB

#endif /* SNABSUITE_COMMON_SNAB_BASE_HPP */