| /* | |
| * Copyright (c) 2010 Massachusetts Institute of Technology | |
| * All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions are | |
| * met: redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer; | |
| * redistributions in binary form must reproduce the above copyright | |
| * notice, this list of conditions and the following disclaimer in the | |
| * documentation and/or other materials provided with the distribution; | |
| * neither the name of the copyright holders nor the names of its | |
| * contributors may be used to endorse or promote products derived from | |
| * this software without specific prior written permission. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| * | |
| * Authors: Chia-Hsin Owen Chen | |
| */ | |
| #ifndef __ORIONCONFIG_H__ | |
| #define __ORIONCONFIG_H__ | |
| #include <iostream> | |
| #include <map> | |
| #include <sstream> | |
| #include "mem/ruby/network/orion/Type.hh" | |
| class TechParameter; | |
| class OrionConfig | |
| { | |
| public: | |
| OrionConfig(const string& cfg_fn_); | |
| OrionConfig(const OrionConfig& orion_cfg_); | |
| ~OrionConfig(); | |
| public: | |
| void set_num_in_port(uint32_t num_in_port_); | |
| void set_num_out_port(uint32_t num_out_port_); | |
| void set_num_vclass(uint32_t num_vclass_); | |
| void set_num_vchannel(uint32_t num_vchannel_); | |
| void set_in_buf_num_set(uint32_t in_buf_num_set_); | |
| void set_flit_width(uint32_t flit_width_); | |
| void read_file(const std::string& filename_); | |
| void print_config(std::ostream& out_); | |
| public: | |
| template<class T> | |
| T get(const std::string& key_) const; | |
| const TechParameter* get_tech_param_ptr() const { return m_tech_param_ptr; } | |
| uint32_t get_num_in_port() const { return m_num_in_port; } | |
| uint32_t get_num_out_port() const { return m_num_out_port; } | |
| uint32_t get_num_vclass() const { return m_num_vclass; } | |
| uint32_t get_num_vchannel() const { return m_num_vchannel; } | |
| uint32_t get_in_buf_num_set() const { return m_in_buf_num_set; } | |
| uint32_t get_flit_width() const { return m_flit_width; } | |
| private: | |
| std::map<std::string, std::string> m_params_map; | |
| TechParameter* m_tech_param_ptr; | |
| uint32_t m_num_in_port; | |
| uint32_t m_num_out_port; | |
| uint32_t m_num_vclass; | |
| uint32_t m_num_vchannel; | |
| uint32_t m_in_buf_num_set; | |
| uint32_t m_flit_width; | |
| protected: | |
| struct key_not_found | |
| { | |
| std::string m_key; | |
| key_not_found(const std::string& key_ = string()) : m_key(key_) | |
| {} | |
| }; | |
| template<class T> | |
| static T string_as_T(const std::string& str_); | |
| template<class T> | |
| static std::string T_as_string(const T& t_); | |
| private: | |
| static std::string ms_param_name[]; | |
| }; | |
| template<class T> | |
| T OrionConfig::get(const string& key_) const | |
| { | |
| std::map<std::string, std::string>::const_iterator it; | |
| it = m_params_map.find(key_); | |
| if (it == m_params_map.end()) | |
| { | |
| std::cerr << key_ << " NOT FOUND!" << std::endl; | |
| throw key_not_found(key_); | |
| } | |
| return string_as_T<T>(it->second); | |
| } | |
| template<class T> | |
| T OrionConfig::string_as_T(const string& str_) | |
| { | |
| T ret; | |
| std::istringstream ist(str_); | |
| ist >> ret; | |
| return ret; | |
| } | |
| template<> | |
| inline string OrionConfig::string_as_T<string>(const string& str_) | |
| { | |
| return str_; | |
| } | |
| template<> | |
| inline bool OrionConfig::string_as_T<bool>(const string& str_) | |
| { | |
| bool ret; | |
| if (str_ == string("TRUE")) | |
| { | |
| ret = true; | |
| } | |
| else if (str_ == string("FALSE")) | |
| { | |
| ret = false; | |
| } | |
| else | |
| { | |
| std::cerr << "Invalid bool value: '" << str_ << | |
| "'. Treated as FALSE." << std::endl; | |
| ret = false; | |
| } | |
| return ret; | |
| } | |
| template<class T> | |
| string OrionConfig::T_as_string(const T& t) | |
| { | |
| std::ostringstream ost; | |
| ost << t; | |
| return ost.str(); | |
| } | |
| #endif | |