src/base/time.cc

   1 /*
   2  * Copyright (c) 2003-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "base/time.hh"
  30
  31 #include <cstdlib>
  32 #include <ctime>
  33 #include <iostream>
  34 #include <sstream>
  35
  36 #include "base/logging.hh"
  37 #include "config/use_posix_clock.hh"
  38 #include "sim/core.hh"
  39 #include "sim/serialize.hh"
  40
  41 void
  42 Time::_set(bool monotonic)
  43 {
  44 #if USE_POSIX_CLOCK
  45     ::clock_gettime(monotonic ? CLOCK_MONOTONIC : CLOCK_REALTIME, &_time);
  46 #else
  47     timeval tv;
  48     ::gettimeofday(&tv, NULL);
  49     operator=(tv);
  50 #endif
  51 }
  52
  53 void
  54 Time::setTick(Tick ticks)
  55 {
  56     uint64_t secs = ticks / SimClock::Frequency;
  57     ticks -= secs * SimClock::Frequency;
  58     uint64_t nsecs = static_cast<uint64_t>(ticks * SimClock::Float::GHz);
  59     set(secs, nsecs);
  60 }
  61
  62 Tick
  63 Time::getTick() const
  64 {
  65     return sec() * SimClock::Frequency +
  66         static_cast<uint64_t>(nsec() * SimClock::Float::ns);
  67 }
  68
  69 std::string
  70 Time::date(const std::string &format) const
  71 {
  72     time_t sec = this->sec();
  73     char buf[256];
  74
  75     if (format.empty()) {
  76 #ifdef __SUNPRO_CC
  77         ctime_r(&sec, buf, sizeof(buf));
  78 #else
  79         ctime_r(&sec, buf);
  80 #endif
  81         buf[24] = '\0';
  82         return buf;
  83     }
  84
  85     struct tm *tm = localtime(&sec);
  86     strftime(buf, sizeof(buf), format.c_str(), tm);
  87     return buf;
  88 }
  89
  90 std::string
  91 Time::time() const
  92 {
  93     double time = double(*this);
  94     double secs = fmod(time, 60.0);
  95     double all_mins = floor(time / 60.0);
  96     double mins = fmod(all_mins, 60.0);
  97     double hours = floor(all_mins / 60.0);
  98
  99     std::stringstream str;
 100
 101     if (hours > 0.0) {
 102         if (hours < 10.0)
 103             str << '0';
 104         str << hours << ':';
 105     }
 106
 107     if (mins > 0.0) {
 108         if (mins < 10.0)
 109             str << '0';
 110         str << mins << ':';
 111     }
 112
 113     if (secs < 10.0 && !str.str().empty())
 114         str << '0';
 115     str << secs;
 116
 117     return str.str();
 118 }
 119
 120 void
 121 Time::serialize(const std::string &base, CheckpointOut &cp) const
 122 {
 123     paramOut(cp, base + ".sec", sec());
 124     paramOut(cp, base + ".nsec", nsec());
 125 }
 126
 127 void
 128 Time::unserialize(const std::string &base, CheckpointIn &cp)
 129 {
 130     time_t secs;
 131     time_t nsecs;
 132     paramIn(cp, base + ".sec", secs);
 133     paramIn(cp, base + ".nsec", nsecs);
 134     sec(secs);
 135     nsec(nsecs);
 136 }
 137
 138 void
 139 sleep(const Time &time)
 140 {
 141     timespec ts = time;
 142
 143 #if USE_POSIX_CLOCK
 144     clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
 145 #else
 146     nanosleep(&ts, NULL);
 147 #endif
 148 }
 149
 150 time_t
 151 mkutctime(struct tm *time)
 152 {
 153     // get the current timezone
 154     char *tz = getenv("TZ");
 155
 156     // copy the string as the pointer gets invalidated when updating
 157     // the environment
 158     if (tz) {
 159         tz = strdup(tz);
 160         if (!tz) {
 161             fatal("Failed to reserve memory for UTC time conversion\n");
 162         }
 163     }
 164
 165     // change to UTC and get the time
 166     setenv("TZ", "", 1);
 167     tzset();
 168     time_t ret = mktime(time);
 169
 170     // restore the timezone again
 171     if (tz) {
 172         setenv("TZ", tz, 1);
 173         free(tz);
 174     } else {
 175         unsetenv("TZ");
 176     }
 177     tzset();
 178
 179     return ret;
 180 }
 181