util/cxx_config/main.cc - amd/gem5 - Git at Google

 /*
  * Copyright (c) 2014 ARM Limited
  * All rights reserved
  *
  * The license below extends only to copyright in the software and shall
  * not be construed as granting a license to any other intellectual
  * property including but not limited to intellectual property relating
  * to a hardware implementation of the functionality of the software
  * licensed hereunder.  You may use the software subject to the license
  * terms below provided that you ensure that this notice is replicated
  * unmodified and in its entirety in all distributions of the software,
  * modified or unmodified, in source code or in binary form.
  *
  * 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: Andrew Bardsley
  */

 /**
  * @file
  *
  *  C++-only configuration and instantiation support.  This allows a
  *  config to be read back from a .ini and instantiated without
  *  Python.  Useful if you want to embed gem5 within a larger system
  *  without carrying the integration cost of the fully-featured
  *  configuration system.
  *
  *  This file contains a demonstration main using CxxConfigManager.
  *  Build with something like:
  *
  *      scons --without-python build/ARM/libgem5_opt.so
  *
  *      g++ -DTRACING_ON -std=c++0x -Ibuild/ARM src/sim/cxx_main.cc \
  *          -o gem5cxx.opt -Lbuild/ARM -lgem5_opt
  */

 #include <cstdlib>
 #include <iostream>
 #include <sstream>

 #include "base/inifile.hh"
 #include "base/statistics.hh"
 #include "base/str.hh"
 #include "base/trace.hh"
 #include "cpu/base.hh"
 #include "sim/cxx_config_ini.hh"
 #include "sim/cxx_manager.hh"
 #include "sim/init_signals.hh"
 #include "sim/serialize.hh"
 #include "sim/sim_events.hh"
 #include "sim/simulate.hh"
 #include "sim/stat_control.hh"
 #include "sim/system.hh"
 #include "stats.hh"

 void
 usage(const std::string &prog_name)
 {
     std::cerr << "Usage: " << prog_name << (
         " <config-file.ini> [ <option> ]\n\n"
         "OPTIONS:\n"
         "    -p <object> <param> <value>  -- set a parameter\n"
         "    -v <object> <param> <values> -- set a vector parameter from"
         " a comma\n"
         "                                    separated values string\n"
         "    -d <flag>                    -- set a debug flag (-<flag>\n"
         "                                    clear a flag)\n"
         "    -s <dir> <ticks>             -- save checkpoint to dir after"
         " the given\n"
         "                                    number of ticks\n"
         "    -r <dir>                     -- restore checkpoint from dir\n"
         "    -c <from> <to> <ticks>       -- switch from cpu 'from' to cpu"
         " 'to' after\n"
         "                                    the given number of ticks\n"
         "\n"
         );

     std::exit(EXIT_FAILURE);
 }

 int
 main(int argc, char **argv)
 {
     std::string prog_name(argv[0]);
     unsigned int arg_ptr = 1;

     if (argc == 1)
         usage(prog_name);

     cxxConfigInit();

     initSignals();

     setClockFrequency(1000000000000);
     curEventQueue(getEventQueue(0));

     Stats::initSimStats();
     Stats::registerHandlers(CxxConfig::statsReset, CxxConfig::statsDump);

     Trace::enable();
     setDebugFlag("Terminal");
     // setDebugFlag("CxxConfig");

     const std::string config_file(argv[arg_ptr]);

     CxxConfigFileBase *conf = new CxxIniFile();

     if (!conf->load(config_file.c_str())) {
         std::cerr << "Can't open config file: " << config_file << '\n';
         return EXIT_FAILURE;
     }
     arg_ptr++;

     CxxConfigManager *config_manager = new CxxConfigManager(*conf);

     bool checkpoint_restore = false;
     bool checkpoint_save = false;
     bool switch_cpus = false;
     std::string checkpoint_dir = "";
     std::string from_cpu = "";
     std::string to_cpu = "";
     Tick pre_run_time = 1000000;
     Tick pre_switch_time = 1000000;

     try {
         while (arg_ptr < argc) {
             std::string option(argv[arg_ptr]);
             arg_ptr++;
             unsigned num_args = argc - arg_ptr;

             if (option == "-p") {
                 if (num_args < 3)
                     usage(prog_name);
                 config_manager->setParam(argv[arg_ptr], argv[arg_ptr + 1],
                     argv[arg_ptr + 2]);
                 arg_ptr += 3;
             } else if (option == "-v") {
                 std::vector<std::string> values;

                 if (num_args < 3)
                     usage(prog_name);
                 tokenize(values, argv[arg_ptr + 2], ',');
                 config_manager->setParamVector(argv[arg_ptr],
                     argv[arg_ptr + 1], values);
                 arg_ptr += 3;
             } else if (option == "-d") {
                 if (num_args < 1)
                     usage(prog_name);
                 if (argv[arg_ptr][0] == '-')
                     clearDebugFlag(argv[arg_ptr] + 1);
                 else
                     setDebugFlag(argv[arg_ptr]);
                 arg_ptr++;
             } else if (option == "-r") {
                 if (num_args < 1)
                     usage(prog_name);
                 checkpoint_dir = argv[arg_ptr];
                 checkpoint_restore = true;
                 arg_ptr++;
             } else if (option == "-s") {
                 if (num_args < 2)
                     usage(prog_name);
                 checkpoint_dir = argv[arg_ptr];
                 std::istringstream(argv[arg_ptr + 1]) >> pre_run_time;
                 checkpoint_save = true;
                 arg_ptr += 2;
             } else if (option == "-c") {
                 if (num_args < 3)
                     usage(prog_name);
                 switch_cpus = true;
                 from_cpu = argv[arg_ptr];
                 to_cpu = argv[arg_ptr + 1];
                 std::istringstream(argv[arg_ptr + 2]) >> pre_switch_time;
                 arg_ptr += 3;
             } else {
                 usage(prog_name);
             }
         }
     } catch (CxxConfigManager::Exception &e) {
         std::cerr << e.name << ": " << e.message << "\n";
         return EXIT_FAILURE;
     }

     if (checkpoint_save && checkpoint_restore) {
         std::cerr << "Don't try and save and restore a checkpoint in the"
             " same run\n";
         return EXIT_FAILURE;
     }

     CxxConfig::statsEnable();
     getEventQueue(0)->dump();

     try {
         config_manager->instantiate();
         if (!checkpoint_restore) {
             config_manager->initState();
             config_manager->startup();
         }
     } catch (CxxConfigManager::Exception &e) {
         std::cerr << "Config problem in sim object " << e.name
             << ": " << e.message << "\n";

         return EXIT_FAILURE;
     }

     GlobalSimLoopExitEvent *exit_event = NULL;

     if (checkpoint_save) {
         exit_event = simulate(pre_run_time);

         unsigned int drain_count = 1;
         do {
             drain_count = config_manager->drain();

             std::cerr << "Draining " << drain_count << '\n';

             if (drain_count > 0) {
                 exit_event = simulate();
             }
         } while (drain_count > 0);

         std::cerr << "Simulation stop at tick " << curTick()
             << ", cause: " << exit_event->getCause() << '\n';

         std::cerr << "Checkpointing\n";

         /* FIXME, this should really be serialising just for
          *  config_manager rather than using serializeAll's ugly
          *  SimObject static object list */
         Serializable::serializeAll(checkpoint_dir);

         std::cerr << "Completed checkpoint\n";

         config_manager->drainResume();
     }

     if (checkpoint_restore) {
         std::cerr << "Restoring checkpoint\n";

         CheckpointIn *checkpoint = new CheckpointIn(checkpoint_dir,
             config_manager->getSimObjectResolver());

         DrainManager::instance().preCheckpointRestore();
         Serializable::unserializeGlobals(*checkpoint);
         config_manager->loadState(*checkpoint);
         config_manager->startup();

         config_manager->drainResume();

         std::cerr << "Restored from checkpoint\n";
     }

     if (switch_cpus) {
         exit_event = simulate(pre_switch_time);

         std::cerr << "Switching CPU\n";

         /* Assume the system is called system */
         System &system = config_manager->getObject<System>("system");
         BaseCPU &old_cpu = config_manager->getObject<BaseCPU>(from_cpu);
         BaseCPU &new_cpu = config_manager->getObject<BaseCPU>(to_cpu);

         unsigned int drain_count = 1;
         do {
             drain_count = config_manager->drain();

             std::cerr << "Draining " << drain_count << '\n';

             if (drain_count > 0) {
                 exit_event = simulate();
             }
         } while (drain_count > 0);

         old_cpu.switchOut();
         system.setMemoryMode(Enums::timing);
         new_cpu.takeOverFrom(&old_cpu);
         config_manager->drainResume();

         std::cerr << "Switched CPU\n";
     }

     exit_event = simulate();

     std::cerr << "Exit at tick " << curTick()
         << ", cause: " << exit_event->getCause() << '\n';

     getEventQueue(0)->dump();

 #if TRY_CLEAN_DELETE
     config_manager->deleteObjects();
 #endif

     delete config_manager;

     return EXIT_SUCCESS;
 }
	/*
	* Copyright (c) 2014 ARM Limited
	* All rights reserved
	*
	* The license below extends only to copyright in the software and shall
	* not be construed as granting a license to any other intellectual
	* property including but not limited to intellectual property relating
	* to a hardware implementation of the functionality of the software
	* licensed hereunder. You may use the software subject to the license
	* terms below provided that you ensure that this notice is replicated
	* unmodified and in its entirety in all distributions of the software,
	* modified or unmodified, in source code or in binary form.
	*
	* 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: Andrew Bardsley
	*/

	/**
	* @file
	*
	* C++-only configuration and instantiation support. This allows a
	* config to be read back from a .ini and instantiated without
	* Python. Useful if you want to embed gem5 within a larger system
	* without carrying the integration cost of the fully-featured
	* configuration system.
	*
	* This file contains a demonstration main using CxxConfigManager.
	* Build with something like:
	*
	* scons --without-python build/ARM/libgem5_opt.so
	*
	* g++ -DTRACING_ON -std=c++0x -Ibuild/ARM src/sim/cxx_main.cc \
	* -o gem5cxx.opt -Lbuild/ARM -lgem5_opt
	*/

	#include <cstdlib>
	#include <iostream>
	#include <sstream>

	#include "base/inifile.hh"
	#include "base/statistics.hh"
	#include "base/str.hh"
	#include "base/trace.hh"
	#include "cpu/base.hh"
	#include "sim/cxx_config_ini.hh"
	#include "sim/cxx_manager.hh"
	#include "sim/init_signals.hh"
	#include "sim/serialize.hh"
	#include "sim/sim_events.hh"
	#include "sim/simulate.hh"
	#include "sim/stat_control.hh"
	#include "sim/system.hh"
	#include "stats.hh"

	void
	usage(const std::string &prog_name)
	{
	std::cerr << "Usage: " << prog_name << (
	" <config-file.ini> [ <option> ]\n\n"
	"OPTIONS:\n"
	" -p <object> <param> <value> -- set a parameter\n"
	" -v <object> <param> <values> -- set a vector parameter from"
	" a comma\n"
	" separated values string\n"
	" -d <flag> -- set a debug flag (-<flag>\n"
	" clear a flag)\n"
	" -s <dir> <ticks> -- save checkpoint to dir after"
	" the given\n"
	" number of ticks\n"
	" -r <dir> -- restore checkpoint from dir\n"
	" -c <from> <to> <ticks> -- switch from cpu 'from' to cpu"
	" 'to' after\n"
	" the given number of ticks\n"
	"\n"
	);

	std::exit(EXIT_FAILURE);
	}

	int
	main(int argc, char **argv)
	{
	std::string prog_name(argv[0]);
	unsigned int arg_ptr = 1;

	if (argc == 1)
	usage(prog_name);

	cxxConfigInit();

	initSignals();

	setClockFrequency(1000000000000);
	curEventQueue(getEventQueue(0));

	Stats::initSimStats();
	Stats::registerHandlers(CxxConfig::statsReset, CxxConfig::statsDump);

	Trace::enable();
	setDebugFlag("Terminal");
	// setDebugFlag("CxxConfig");

	const std::string config_file(argv[arg_ptr]);

	CxxConfigFileBase *conf = new CxxIniFile();

	if (!conf->load(config_file.c_str())) {
	std::cerr << "Can't open config file: " << config_file << '\n';
	return EXIT_FAILURE;
	}
	arg_ptr++;

	CxxConfigManager config_manager = new CxxConfigManager(conf);

	bool checkpoint_restore = false;
	bool checkpoint_save = false;
	bool switch_cpus = false;
	std::string checkpoint_dir = "";
	std::string from_cpu = "";
	std::string to_cpu = "";
	Tick pre_run_time = 1000000;
	Tick pre_switch_time = 1000000;

	try {
	while (arg_ptr < argc) {
	std::string option(argv[arg_ptr]);
	arg_ptr++;
	unsigned num_args = argc - arg_ptr;

	if (option == "-p") {
	if (num_args < 3)
	usage(prog_name);
	config_manager->setParam(argv[arg_ptr], argv[arg_ptr + 1],
	argv[arg_ptr + 2]);
	arg_ptr += 3;
	} else if (option == "-v") {
	std::vector<std::string> values;

	if (num_args < 3)
	usage(prog_name);
	tokenize(values, argv[arg_ptr + 2], ',');
	config_manager->setParamVector(argv[arg_ptr],
	argv[arg_ptr + 1], values);
	arg_ptr += 3;
	} else if (option == "-d") {
	if (num_args < 1)
	usage(prog_name);
	if (argv[arg_ptr][0] == '-')
	clearDebugFlag(argv[arg_ptr] + 1);
	else
	setDebugFlag(argv[arg_ptr]);
	arg_ptr++;
	} else if (option == "-r") {
	if (num_args < 1)
	usage(prog_name);
	checkpoint_dir = argv[arg_ptr];
	checkpoint_restore = true;
	arg_ptr++;
	} else if (option == "-s") {
	if (num_args < 2)
	usage(prog_name);
	checkpoint_dir = argv[arg_ptr];
	std::istringstream(argv[arg_ptr + 1]) >> pre_run_time;
	checkpoint_save = true;
	arg_ptr += 2;
	} else if (option == "-c") {
	if (num_args < 3)
	usage(prog_name);
	switch_cpus = true;
	from_cpu = argv[arg_ptr];
	to_cpu = argv[arg_ptr + 1];
	std::istringstream(argv[arg_ptr + 2]) >> pre_switch_time;
	arg_ptr += 3;
	} else {
	usage(prog_name);
	}
	}
	} catch (CxxConfigManager::Exception &e) {
	std::cerr << e.name << ": " << e.message << "\n";
	return EXIT_FAILURE;
	}

	if (checkpoint_save && checkpoint_restore) {
	std::cerr << "Don't try and save and restore a checkpoint in the"
	" same run\n";
	return EXIT_FAILURE;
	}

	CxxConfig::statsEnable();
	getEventQueue(0)->dump();

	try {
	config_manager->instantiate();
	if (!checkpoint_restore) {
	config_manager->initState();
	config_manager->startup();
	}
	} catch (CxxConfigManager::Exception &e) {
	std::cerr << "Config problem in sim object " << e.name
	<< ": " << e.message << "\n";

	return EXIT_FAILURE;
	}

	GlobalSimLoopExitEvent *exit_event = NULL;

	if (checkpoint_save) {
	exit_event = simulate(pre_run_time);

	unsigned int drain_count = 1;
	do {
	drain_count = config_manager->drain();

	std::cerr << "Draining " << drain_count << '\n';

	if (drain_count > 0) {
	exit_event = simulate();
	}
	} while (drain_count > 0);

	std::cerr << "Simulation stop at tick " << curTick()
	<< ", cause: " << exit_event->getCause() << '\n';

	std::cerr << "Checkpointing\n";

	/* FIXME, this should really be serialising just for
	* config_manager rather than using serializeAll's ugly
	* SimObject static object list */
	Serializable::serializeAll(checkpoint_dir);

	std::cerr << "Completed checkpoint\n";

	config_manager->drainResume();
	}

	if (checkpoint_restore) {
	std::cerr << "Restoring checkpoint\n";

	CheckpointIn *checkpoint = new CheckpointIn(checkpoint_dir,
	config_manager->getSimObjectResolver());

	DrainManager::instance().preCheckpointRestore();
	Serializable::unserializeGlobals(*checkpoint);
	config_manager->loadState(*checkpoint);
	config_manager->startup();

	config_manager->drainResume();

	std::cerr << "Restored from checkpoint\n";
	}

	if (switch_cpus) {
	exit_event = simulate(pre_switch_time);

	std::cerr << "Switching CPU\n";

	/* Assume the system is called system */
	System &system = config_manager->getObject<System>("system");
	BaseCPU &old_cpu = config_manager->getObject<BaseCPU>(from_cpu);
	BaseCPU &new_cpu = config_manager->getObject<BaseCPU>(to_cpu);

	unsigned int drain_count = 1;
	do {
	drain_count = config_manager->drain();

	std::cerr << "Draining " << drain_count << '\n';

	if (drain_count > 0) {
	exit_event = simulate();
	}
	} while (drain_count > 0);

	old_cpu.switchOut();
	system.setMemoryMode(Enums::timing);
	new_cpu.takeOverFrom(&old_cpu);
	config_manager->drainResume();

	std::cerr << "Switched CPU\n";
	}

	exit_event = simulate();

	std::cerr << "Exit at tick " << curTick()
	<< ", cause: " << exit_event->getCause() << '\n';

	getEventQueue(0)->dump();

	#if TRY_CLEAN_DELETE
	config_manager->deleteObjects();
	#endif

	delete config_manager;

	return EXIT_SUCCESS;
	}