src/sim/power_state.cc - public/gem5 - Git at Google

 /*
  * Copyright (c) 2015-2017, 2019-2020 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.
  */

 #include "sim/power_state.hh"

 #include "base/logging.hh"
 #include "base/trace.hh"
 #include "debug/PowerDomain.hh"
 #include "sim/power_domain.hh"

 PowerState::PowerState(const PowerStateParams *p) :
     SimObject(p), _currState(p->default_state),
     possibleStates(p->possible_states.begin(),
                    p->possible_states.end()),
     stats(*this)
 {
     for (auto &pm: p->leaders) {
         // Register this object as a follower. This object is
         // dependent on pm for power state transitions
         pm->addFollower(this);
     }
 }

 void
 PowerState::setControlledDomain(PowerDomain* pwr_dom)
 {
     // Only a power domain can register as dependant of a power stated
     // object
     controlledDomain = pwr_dom;
     DPRINTF(PowerDomain, "%s is registered as controlled by %s \n",
                          pwr_dom->name(), name());
 }

 void
 PowerState::serialize(CheckpointOut &cp) const
 {
     unsigned int currState = (unsigned int)_currState;

     SERIALIZE_SCALAR(currState);
     SERIALIZE_SCALAR(prvEvalTick);
 }

 void
 PowerState::unserialize(CheckpointIn &cp)
 {
     unsigned int currState;

     UNSERIALIZE_SCALAR(currState);
     UNSERIALIZE_SCALAR(prvEvalTick);

     _currState = Enums::PwrState(currState);
 }

 void
 PowerState::set(Enums::PwrState p)
 {
     // Check if this power state is actually allowed by checking whether it is
     // present in pwrStateToIndex-dictionary
     panic_if(possibleStates.find(p) == possibleStates.end(),
              "Cannot go to %s in %s \n", Enums::PwrStateStrings[p], name());

     // Function should ideally be called only when there is a state change
     if (_currState == p) {
         warn_once("PowerState: Already in the requested power state, "
                   "request ignored");
         return;
     }

     // No need to compute stats if in the same tick, update state though. This
     // can happen in cases like a) during start of the simulation multiple
     // state changes happens in init/startup phase, b) one takes a decision to
     // migrate state but decides to reverts back to the original state in the
     // same tick if other conditions are not met elsewhere.
     // Any state change related stats would have been recorded on previous call
     // to this function.
     if (prvEvalTick == curTick() && curTick() != 0) {
         warn("PowerState: More than one power state change request "
              "encountered within the same simulation tick");
         _currState = p;
         return;
     }

     // Record stats for previous state.
     computeStats();

     _currState = p;

     stats.numTransitions++;

     // Update the domain this object controls, if there is one
     if (controlledDomain) {
         controlledDomain->pwrStateChangeCallback(p, this);
     }

 }

 Enums::PwrState
 PowerState::matchPwrState(Enums::PwrState p)
 {
     // If the object is asked to match a power state, it has to be a follower
     // and hence should not have a pointer to a powerDomain
     assert(controlledDomain == nullptr);

     // If we are already in this power state, ignore request
     if (_currState == p) {
         DPRINTF(PowerDomain, "Already in p-state %s requested to match \n",
                 Enums::PwrStateStrings[p]);
         return _currState;
     }

     Enums::PwrState old_state = _currState;
     if (possibleStates.find(p) != possibleStates.end()) {
         // If this power state is allowed in this object, just go there
         set(p);
     } else {
         // Loop over all power states in this object and find a power state
         // which is more performant than the requested one (considering we
         // cannot match it exactly)
         for (auto rev_it = possibleStates.crbegin();
              rev_it != possibleStates.crend(); rev_it++) {
             if (*(rev_it) <= p) {
                 // This power state is the least performant power state that is
                 // still more performant than the requested one
                 DPRINTF(PowerDomain, "Best match for %s is %s \n",
                         Enums::PwrStateStrings[p],
                         Enums::PwrStateStrings[*(rev_it)]);
                 set(*(rev_it));
                 break;
             }
         }
     }
     // Check if the transition happened
     // The only case in which the power state cannot change is if the
     // object is already at in its most performant state.
     warn_if((_currState == old_state) &&
             possibleStates.find(_currState) != possibleStates.begin(),
             "Transition to power state %s was not possible, SimObject already"
             " in the most performance state %s",
             Enums::PwrStateStrings[p], Enums::PwrStateStrings[_currState]);

     stats.numPwrMatchStateTransitions++;
     return _currState;
 }

 void
 PowerState::computeStats()
 {
     // Calculate time elapsed from last (valid) state change
     Tick elapsed_time = curTick() - prvEvalTick;

     stats.pwrStateResidencyTicks[_currState] += elapsed_time;

     // Time spent in CLK_GATED state, this might change depending on
     // transition to other low power states in respective simulation
     // objects.
     if (_currState == Enums::PwrState::CLK_GATED) {
         stats.ticksClkGated.sample(elapsed_time);
     }

     prvEvalTick = curTick();
 }

 std::vector<double>
 PowerState::getWeights() const
 {
     // Get residency stats
     std::vector<double> ret;
     Stats::VCounter residencies;
     stats.pwrStateResidencyTicks.value(residencies);

     // Account for current state too!
     Tick elapsed_time = curTick() - prvEvalTick;
     residencies[_currState] += elapsed_time;

     ret.resize(Enums::PwrState::Num_PwrState);
     for (unsigned i = 0; i < Enums::PwrState::Num_PwrState; i++)
         ret[i] = residencies[i] / \
                      (stats.pwrStateResidencyTicks.total() + elapsed_time);

     return ret;
 }

 PowerState::PowerStateStats::PowerStateStats(PowerState &co)
     : Stats::Group(&co),
     powerState(co),
     ADD_STAT(numTransitions,
              "Number of power state transitions"),
     ADD_STAT(numPwrMatchStateTransitions,
              "Number of power state transitions due match request"),
     ADD_STAT(ticksClkGated,
              "Distribution of time spent in the clock gated state"),
     ADD_STAT(pwrStateResidencyTicks,
              "Cumulative time (in ticks) in various power states")
 {
 }

 void
 PowerState::PowerStateStats::regStats()
 {
     Stats::Group::regStats();

     using namespace Stats;

     const PowerStateParams *p = powerState.params();

     numTransitions.flags(nozero);
     numPwrMatchStateTransitions.flags(nozero);

     // Each sample is time in ticks
     unsigned num_bins = std::max(p->clk_gate_bins, 10U);
     ticksClkGated
         .init(p->clk_gate_min, p->clk_gate_max,
               (p->clk_gate_max / num_bins))
         .flags(pdf | nozero | nonan)
         ;

     pwrStateResidencyTicks
         .init(Enums::PwrState::Num_PwrState)
         .flags(nozero)
         ;
     for (int i = 0; i < Enums::PwrState::Num_PwrState; i++) {
         pwrStateResidencyTicks.subname(i, Enums::PwrStateStrings[i]);
     }

     numTransitions = 0;
 }

 void
 PowerState::PowerStateStats::preDumpStats()
 {
     Stats::Group::preDumpStats();

     /**
      * For every stats dump, the power state residency and other distribution
      * stats should be computed just before the dump to ensure correct stats
      * value being reported for current dump window. It avoids things like
      * having any unreported time spent in a power state to be forwarded to the
      * next dump window which might have rather unpleasant effects (like
      * perturbing the distribution stats).
      */
     powerState.computeStats();
 }

 PowerState*
 PowerStateParams::create()
 {
     return new PowerState(this);
 }
	/*
	* Copyright (c) 2015-2017, 2019-2020 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.
	*/

	#include "sim/power_state.hh"

	#include "base/logging.hh"
	#include "base/trace.hh"
	#include "debug/PowerDomain.hh"
	#include "sim/power_domain.hh"

	PowerState::PowerState(const PowerStateParams *p) :
	SimObject(p), _currState(p->default_state),
	possibleStates(p->possible_states.begin(),
	p->possible_states.end()),
	stats(*this)
	{
	for (auto &pm: p->leaders) {
	// Register this object as a follower. This object is
	// dependent on pm for power state transitions
	pm->addFollower(this);
	}
	}

	void
	PowerState::setControlledDomain(PowerDomain* pwr_dom)
	{
	// Only a power domain can register as dependant of a power stated
	// object
	controlledDomain = pwr_dom;
	DPRINTF(PowerDomain, "%s is registered as controlled by %s \n",
	pwr_dom->name(), name());
	}

	void
	PowerState::serialize(CheckpointOut &cp) const
	{
	unsigned int currState = (unsigned int)_currState;

	SERIALIZE_SCALAR(currState);
	SERIALIZE_SCALAR(prvEvalTick);
	}

	void
	PowerState::unserialize(CheckpointIn &cp)
	{
	unsigned int currState;

	UNSERIALIZE_SCALAR(currState);
	UNSERIALIZE_SCALAR(prvEvalTick);

	_currState = Enums::PwrState(currState);
	}

	void
	PowerState::set(Enums::PwrState p)
	{
	// Check if this power state is actually allowed by checking whether it is
	// present in pwrStateToIndex-dictionary
	panic_if(possibleStates.find(p) == possibleStates.end(),
	"Cannot go to %s in %s \n", Enums::PwrStateStrings[p], name());

	// Function should ideally be called only when there is a state change
	if (_currState == p) {
	warn_once("PowerState: Already in the requested power state, "
	"request ignored");
	return;
	}

	// No need to compute stats if in the same tick, update state though. This
	// can happen in cases like a) during start of the simulation multiple
	// state changes happens in init/startup phase, b) one takes a decision to
	// migrate state but decides to reverts back to the original state in the
	// same tick if other conditions are not met elsewhere.
	// Any state change related stats would have been recorded on previous call
	// to this function.
	if (prvEvalTick == curTick() && curTick() != 0) {
	warn("PowerState: More than one power state change request "
	"encountered within the same simulation tick");
	_currState = p;
	return;
	}

	// Record stats for previous state.
	computeStats();

	_currState = p;

	stats.numTransitions++;

	// Update the domain this object controls, if there is one
	if (controlledDomain) {
	controlledDomain->pwrStateChangeCallback(p, this);
	}

	}

	Enums::PwrState
	PowerState::matchPwrState(Enums::PwrState p)
	{
	// If the object is asked to match a power state, it has to be a follower
	// and hence should not have a pointer to a powerDomain
	assert(controlledDomain == nullptr);

	// If we are already in this power state, ignore request
	if (_currState == p) {
	DPRINTF(PowerDomain, "Already in p-state %s requested to match \n",
	Enums::PwrStateStrings[p]);
	return _currState;
	}

	Enums::PwrState old_state = _currState;
	if (possibleStates.find(p) != possibleStates.end()) {
	// If this power state is allowed in this object, just go there
	set(p);
	} else {
	// Loop over all power states in this object and find a power state
	// which is more performant than the requested one (considering we
	// cannot match it exactly)
	for (auto rev_it = possibleStates.crbegin();
	rev_it != possibleStates.crend(); rev_it++) {
	if (*(rev_it) <= p) {
	// This power state is the least performant power state that is
	// still more performant than the requested one
	DPRINTF(PowerDomain, "Best match for %s is %s \n",
	Enums::PwrStateStrings[p],
	Enums::PwrStateStrings[*(rev_it)]);
	set(*(rev_it));
	break;
	}
	}
	}
	// Check if the transition happened
	// The only case in which the power state cannot change is if the
	// object is already at in its most performant state.
	warn_if((_currState == old_state) &&
	possibleStates.find(_currState) != possibleStates.begin(),
	"Transition to power state %s was not possible, SimObject already"
	" in the most performance state %s",
	Enums::PwrStateStrings[p], Enums::PwrStateStrings[_currState]);

	stats.numPwrMatchStateTransitions++;
	return _currState;
	}

	void
	PowerState::computeStats()
	{
	// Calculate time elapsed from last (valid) state change
	Tick elapsed_time = curTick() - prvEvalTick;

	stats.pwrStateResidencyTicks[_currState] += elapsed_time;

	// Time spent in CLK_GATED state, this might change depending on
	// transition to other low power states in respective simulation
	// objects.
	if (_currState == Enums::PwrState::CLK_GATED) {
	stats.ticksClkGated.sample(elapsed_time);
	}

	prvEvalTick = curTick();
	}

	std::vector<double>
	PowerState::getWeights() const
	{
	// Get residency stats
	std::vector<double> ret;
	Stats::VCounter residencies;
	stats.pwrStateResidencyTicks.value(residencies);

	// Account for current state too!
	Tick elapsed_time = curTick() - prvEvalTick;
	residencies[_currState] += elapsed_time;

	ret.resize(Enums::PwrState::Num_PwrState);
	for (unsigned i = 0; i < Enums::PwrState::Num_PwrState; i++)
	ret[i] = residencies[i] / \
	(stats.pwrStateResidencyTicks.total() + elapsed_time);

	return ret;
	}

	PowerState::PowerStateStats::PowerStateStats(PowerState &co)
	: Stats::Group(&co),
	powerState(co),
	ADD_STAT(numTransitions,
	"Number of power state transitions"),
	ADD_STAT(numPwrMatchStateTransitions,
	"Number of power state transitions due match request"),
	ADD_STAT(ticksClkGated,
	"Distribution of time spent in the clock gated state"),
	ADD_STAT(pwrStateResidencyTicks,
	"Cumulative time (in ticks) in various power states")
	{
	}

	void
	PowerState::PowerStateStats::regStats()
	{
	Stats::Group::regStats();

	using namespace Stats;

	const PowerStateParams *p = powerState.params();

	numTransitions.flags(nozero);
	numPwrMatchStateTransitions.flags(nozero);

	// Each sample is time in ticks
	unsigned num_bins = std::max(p->clk_gate_bins, 10U);
	ticksClkGated
	.init(p->clk_gate_min, p->clk_gate_max,
	(p->clk_gate_max / num_bins))
	.flags(pdf \| nozero \| nonan)
	;

	pwrStateResidencyTicks
	.init(Enums::PwrState::Num_PwrState)
	.flags(nozero)
	;
	for (int i = 0; i < Enums::PwrState::Num_PwrState; i++) {
	pwrStateResidencyTicks.subname(i, Enums::PwrStateStrings[i]);
	}

	numTransitions = 0;
	}

	void
	PowerState::PowerStateStats::preDumpStats()
	{
	Stats::Group::preDumpStats();

	/**
	* For every stats dump, the power state residency and other distribution
	* stats should be computed just before the dump to ensure correct stats
	* value being reported for current dump window. It avoids things like
	* having any unreported time spent in a power state to be forwarded to the
	* next dump window which might have rather unpleasant effects (like
	* perturbing the distribution stats).
	*/
	powerState.computeStats();
	}

	PowerState*
	PowerStateParams::create()
	{
	return new PowerState(this);
	}