PFPObject.h

/*
 * PFPSim: Library for the Programmable Forwarding Plane Simulation Framework
 *
 * Copyright (C) 2016 Concordia Univ., Montreal
 *     Samar Abdi
 *     Umair Aftab
 *     Gordon Bailey
 *     Faras Dewal
 *     Shafigh Parsazad
 *     Eric Tremblay
 *
 * Copyright (C) 2016 Ericsson
 *     Bochra Boughzala
 *
 * 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef CORE_PFPOBJECT_H_
#define CORE_PFPOBJECT_H_
#include <string>
#include <vector>
#include <map>
#include "systemc.h"  // NOLINT(build/include)
#include "tlm.h"  // NOLINT(build/include)
#include "TrType.h"
#include "PFPConfig.h"
#include "LMTQueue.h"
#include "MTQueue.h"
#include "PFPObserver.h"
#include "./promptcolors.h"
#include "ConfigurationParameters.h"

#define GetParam(key) get_param_value(configMap, key)
#define GetParamI(key) atoi(get_param_value(configMap, key).c_str())

/*
 * Pre-Processor for NPU Log Levels.
 */

// Format: CommonMacroName_No.ofargs

// Concatenate macro name with number of inputs to base macro
#define CATMACRO(A, B) A ## B
// Select the name based on number of args.
#define SELECTMACRO(NAME, NUM) CATMACRO(NAME ## _, NUM)
// Get count for macros   // Add here for additional number of arguments
#define GET_COUNT(_1, _2, COUNT, ...) COUNT
// Get args         // Add here in reverse for additional number of args.
#define VA_SIZE(...) GET_COUNT(__VA_ARGS__, 2, 1)
#define VA_SELECT(NAME, ...)                                                  \
        SELECTMACRO(NAME, VA_SIZE(__VA_ARGS__))(__VA_ARGS__)  // selector
#define npulog(...) VA_SELECT(LOG, __VA_ARGS__)  // Base Macro

#define npu_error(error_msg) {                                                \
      cerr << "Error: " << (error_msg) << __FILE__ << ":"                     \
      << __LINE__ << endl; sc_stop(); }

#define LOG_1(STAT)\
  if (pfp::core::PFPConfig::get().get_verbose_level()                      \
      != pfp::core::PFPConfig::get().verbosity::minimal                    \
      && pfp::core::PFPConfig::get().get_verbose_level()                   \
      == pfp::core::PFPConfig::get().verbosity::debug) {                   \
      sc_core::sc_time now = sc_time_stamp();                                 \
    cout << txtgrn << std::fixed << now.to_double()/1000 << " ns "            \
          << txtrst << "@ " << txtrst << " ";                                 \
    STAT                                                                      \
    cout << txtrst;                                                           \
}

#define LOG_2(LEVEL, STAT)                                                    \
    if (pfp::core::PFPConfig::get().get_verbose_level()                    \
          == pfp::core::PFPConfig::get().verbosity::LEVEL) {               \
        sc_core::sc_time now = sc_time_stamp();                               \
    std::string modnametemp = module_name_;                                   \
    cout << txtgrn << std::fixed << now.to_double()/1000 << " ns "            \
          << txtrst << "@ " << On_Purple << modnametemp << txtrst << " ";     \
    STAT                                                                      \
    cout << txtrst;                                                           \
    }

//-------------------------------------------------------------------

namespace pfp {
namespace core {
inline std::string convert_to_string(sc_module_name nm) {
  return static_cast<const char*>(nm);
}

class PFPObject {
 public:
  PFPObject();
  PFPObject(const std::string& module_name, PFPObject* parent = 0,
        bool enable_dicp = false);
  PFPObject(const std::string& module_name, std::string BaseConfigFile,
        std::string InstanceConfigFile = "", PFPObject* parent = 0,
        bool enable_dicp = false);
  PFPObject(const PFPObject &other, bool enable_dicp = false);
  virtual ~PFPObject() = default;

  /*--------Configuration of Modules -------------*/
  void LoadBaseConfiguration(std::string);
  void LoadInstanceConfiguration(std::string);

  pfp::core::ConfigurationParameterNode GetParameter(std::string param);
  pfp::core::ConfigurationParameterNode
  GetParameterfromParent(std::string param, PFPObject* parent);

  std::vector<std::string> ModuleHierarchy();
  /* ----- DICP ----- */
  const bool dicp_enabled;

  /* --- Module ---- */
  const std::string& module_name() const;
  PFPObject* GetParent();

  /* --- Observers --- */
  virtual bool add_counter(const std::string& counter_name,
        std::size_t counter_value = 0);
  virtual bool set_counter(const std::string& counter_name,
        std::size_t counter_value);
  virtual bool remove_counter(const std::string& counter_name);
  virtual std::size_t counter_value(const std::string& counter_name) const;
  virtual bool increment_counter(const std::string& counter_name);
  virtual bool increment_counter(const std::string& counter_name,
        const int incr_amount);
  virtual bool decrement_counter(const std::string& counter_name);
  virtual bool decrement_counter(const std::string& counter_name,
        const int decr_amount);
  virtual void attach_observer(std::shared_ptr<PFPObserver> observer);
  virtual void notify_counter_changed(const std::string& counter_name,
        std::size_t counter_value, double sim_time);
  virtual void notify_counter_added(const std::string& counter_name,
        double sim_time);
  virtual void notify_counter_removed(const std::string& counter_name,
        double sim_time);
  virtual std::size_t num_counters() const;
  void AddChildModule(std::string module_name, PFPObject* module);

  // TODO(umair) why are all notify_data_* templated when PFPObserver only
  // handles TrType anyway...
  template <typename DATA_TYPE>
  void notify_data_written(const std::shared_ptr<DATA_TYPE> data,
        double sim_time) {
    for (auto& each_observer : observers_) {
      auto func = std::bind(&PFPObserver::data_written, each_observer,
            module_name(), data, sim_time);
      events_.push(func);
    }
  }
  template <typename DATA_TYPE>
  void notify_data_read(const std::shared_ptr<DATA_TYPE> data,
        double sim_time) {
    for (auto& each_observer : observers_) {
      auto func = std::bind(&PFPObserver::data_read, each_observer,
            module_name(), data, sim_time);
      events_.push(func);
    }
  }
  template <typename DATA_TYPE>
  void notify_data_dropped(const std::shared_ptr<DATA_TYPE> data,
        std::string& drop_reason, double sim_time) {
    for (auto& each_observer : observers_) {
      auto func = std::bind(&PFPObserver::data_dropped, each_observer,
            module_name(), data, drop_reason, sim_time);
      events_.push(func);
    }
  }

  template <typename DATA_TYPE>
  void drop_data(const std::shared_ptr<DATA_TYPE> data,
        std::string drop_reason) {
          notify_data_dropped(data,
                              drop_reason,
                              sc_time_stamp().to_default_time_units());
  }

  pfp::core::ConfigurationParameterNode SimulationParameters;
  static MTQueue<std::function<void(void)>> events_;  
 protected:
  const std::string GlobalConfigPath;
  const std::string module_name_;
  PFPObject* parent_;                
  std::map<std::string, std::string> configMap;  
  std::map<std::string, std::size_t> counters_;
  std::vector<std::shared_ptr<PFPObserver>> observers_;
  std::map<std::string, PFPObject*> childModules_;
};

};  // namespace core
};  // namespace pfp
#endif  // CORE_PFPOBJECT_H_