src/sim/drain.cc

   1 /*
   2  * Copyright (c) 2012, 2015, 2017 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions are
  16  * met: redistributions of source code must retain the above copyright
  17  * notice, this list of conditions and the following disclaimer;
  18  * redistributions in binary form must reproduce the above copyright
  19  * notice, this list of conditions and the following disclaimer in the
  20  * documentation and/or other materials provided with the distribution;
  21  * neither the name of the copyright holders nor the names of its
  22  * contributors may be used to endorse or promote products derived from
  23  * this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * Authors: Andreas Sandberg
  38  */
  39
  40 #include "sim/drain.hh"
  41
  42 #include <algorithm>
  43
  44 #include "base/misc.hh"
  45 #include "base/trace.hh"
  46 #include "debug/Drain.hh"
  47 #include "sim/sim_exit.hh"
  48 #include "sim/sim_object.hh"
  49
  50 DrainManager DrainManager::_instance;
  51
  52 DrainManager::DrainManager()
  53     : _count(0),
  54       _state(DrainState::Running)
  55 {
  56 }
  57
  58 DrainManager::~DrainManager()
  59 {
  60 }
  61
  62 bool
  63 DrainManager::tryDrain()
  64 {
  65     panic_if(_state == DrainState::Drained,
  66              "Trying to drain a drained system\n");
  67
  68     panic_if(_count != 0,
  69              "Drain counter must be zero at the start of a drain cycle\n");
  70
  71     DPRINTF(Drain, "Trying to drain %u objects.\n", drainableCount());
  72     _state = DrainState::Draining;
  73     for (auto *obj : _allDrainable) {
  74         DrainState status = obj->dmDrain();
  75         if (DTRACE(Drain) && status != DrainState::Drained) {
  76             SimObject *temp = dynamic_cast<SimObject*>(obj);
  77             if (temp)
  78                 DPRINTF(Drain, "Failed to drain %s\n", temp->name());
  79         }
  80         _count += status == DrainState::Drained ? 0 : 1;
  81     }
  82
  83     if (_count == 0) {
  84         DPRINTF(Drain, "Drain done.\n");
  85         _state = DrainState::Drained;
  86         return true;
  87     } else {
  88         DPRINTF(Drain, "Need another drain cycle. %u/%u objects not ready.\n",
  89                 _count, drainableCount());
  90         return false;
  91     }
  92 }
  93
  94 void
  95 DrainManager::resume()
  96 {
  97     panic_if(_state == DrainState::Running,
  98              "Trying to resume a system that is already running\n");
  99
 100     warn_if(_state == DrainState::Draining,
 101             "Resuming a system that isn't fully drained, this is untested and "
 102             "likely to break\n");
 103
 104     panic_if(_state == DrainState::Resuming,
 105              "Resuming a system that is already trying to resume. This should "
 106              "never happen.\n");
 107
 108     panic_if(_count != 0,
 109              "Resume called in the middle of a drain cycle. %u objects "
 110              "left to drain.\n", _count);
 111
 112     // At this point in time the DrainManager and all objects will be
 113     // in the the Drained state. New objects (i.e., objects created
 114     // while resuming) will inherit the Resuming state from the
 115     // DrainManager, which means we have to resume objects until all
 116     // objects are in the Running state.
 117     _state = DrainState::Resuming;
 118
 119     do {
 120         DPRINTF(Drain, "Resuming %u objects.\n", drainableCount());
 121         for (auto *obj : _allDrainable) {
 122             if (obj->drainState() != DrainState::Running) {
 123                 assert(obj->drainState() == DrainState::Drained ||
 124                        obj->drainState() == DrainState::Resuming);
 125                 obj->dmDrainResume();
 126             }
 127         }
 128     } while (!allInState(DrainState::Running));
 129
 130     _state = DrainState::Running;
 131 }
 132
 133 void
 134 DrainManager::preCheckpointRestore()
 135 {
 136     panic_if(_state != DrainState::Running,
 137              "preCheckpointRestore() called on a system that isn't in the "
 138              "Running state.\n");
 139
 140     DPRINTF(Drain, "Applying pre-restore fixes to %u objects.\n",
 141             drainableCount());
 142     _state = DrainState::Drained;
 143     for (auto *obj : _allDrainable)
 144         obj->_drainState = DrainState::Drained;
 145 }
 146
 147 void
 148 DrainManager::signalDrainDone()
 149 {
 150     assert(_count > 0);
 151     if (--_count == 0) {
 152         DPRINTF(Drain, "All %u objects drained..\n", drainableCount());
 153         exitSimLoop("Finished drain", 0);
 154     }
 155 }
 156
 157
 158 void
 159 DrainManager::registerDrainable(Drainable *obj)
 160 {
 161     std::lock_guard<std::mutex> lock(globalLock);
 162     assert(std::find(_allDrainable.begin(), _allDrainable.end(), obj) ==
 163            _allDrainable.end());
 164     _allDrainable.push_back(obj);
 165 }
 166
 167 void
 168 DrainManager::unregisterDrainable(Drainable *obj)
 169 {
 170     std::lock_guard<std::mutex> lock(globalLock);
 171     auto o = std::find(_allDrainable.begin(), _allDrainable.end(), obj);
 172     assert(o != _allDrainable.end());
 173     _allDrainable.erase(o);
 174 }
 175
 176 bool
 177 DrainManager::allInState(DrainState state) const
 178 {
 179     for (const auto *obj : _allDrainable) {
 180         if (obj->drainState() != state)
 181             return false;
 182     }
 183
 184     return true;
 185 }
 186
 187 size_t
 188 DrainManager::drainableCount() const
 189 {
 190     std::lock_guard<std::mutex> lock(globalLock);
 191     return _allDrainable.size();
 192 }
 193
 194
 195
 196 Drainable::Drainable()
 197     : _drainManager(DrainManager::instance()),
 198       _drainState(_drainManager.state())
 199 {
 200     _drainManager.registerDrainable(this);
 201 }
 202
 203 Drainable::~Drainable()
 204 {
 205     _drainManager.unregisterDrainable(this);
 206 }
 207
 208 DrainState
 209 Drainable::dmDrain()
 210 {
 211     _drainState = DrainState::Draining;
 212     _drainState = drain();
 213     assert(_drainState == DrainState::Draining ||
 214            _drainState == DrainState::Drained);
 215
 216     return _drainState;
 217 }
 218
 219 void
 220 Drainable::dmDrainResume()
 221 {
 222     panic_if(_drainState != DrainState::Drained &&
 223              _drainState != DrainState::Resuming,
 224              "Trying to resume an object that hasn't been drained\n");
 225
 226     _drainState = DrainState::Running;
 227     drainResume();
 228 }