src/mem/physical.cc

   1 /*
   2  * Copyright (c) 2001-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  * Authors: Ron Dreslinski
  29  *          Ali Saidi
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/mman.h>
  34 #include <errno.h>
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <zlib.h>
  38
  39 #include <iostream>
  40 #include <string>
  41
  42
  43 #include "base/misc.hh"
  44 #include "config/full_system.hh"
  45 #include "mem/packet_impl.hh"
  46 #include "mem/physical.hh"
  47 #include "sim/host.hh"
  48 #include "sim/builder.hh"
  49 #include "sim/eventq.hh"
  50 #include "arch/isa_traits.hh"
  51
  52
  53 using namespace std;
  54 using namespace TheISA;
  55
  56
  57 PhysicalMemory::PhysicalMemory(Params *p)
  58     : MemObject(p->name), pmemAddr(NULL), port(NULL), lat(p->latency), _params(p)
  59 {
  60     if (params()->addrRange.size() % TheISA::PageBytes != 0)
  61         panic("Memory Size not divisible by page size\n");
  62
  63     int map_flags = MAP_ANON | MAP_PRIVATE;
  64     pmemAddr = (uint8_t *)mmap(NULL, params()->addrRange.size(), PROT_READ | PROT_WRITE,
  65                                 map_flags, -1, 0);
  66
  67     if (pmemAddr == (void *)MAP_FAILED) {
  68         perror("mmap");
  69         fatal("Could not mmap!\n");
  70     }
  71
  72     pagePtr = 0;
  73 }
  74
  75 void
  76 PhysicalMemory::init()
  77 {
  78     if (!port)
  79         panic("PhysicalMemory not connected to anything!");
  80     port->sendStatusChange(Port::RangeChange);
  81 }
  82
  83 PhysicalMemory::~PhysicalMemory()
  84 {
  85     if (pmemAddr)
  86         munmap(pmemAddr, params()->addrRange.size());
  87     //Remove memPorts?
  88 }
  89
  90 Addr
  91 PhysicalMemory::new_page()
  92 {
  93     Addr return_addr = pagePtr << LogVMPageSize;
  94     return_addr += params()->addrRange.start;
  95
  96     ++pagePtr;
  97     return return_addr;
  98 }
  99
 100 int
 101 PhysicalMemory::deviceBlockSize()
 102 {
 103     //Can accept anysize request
 104     return 0;
 105 }
 106
 107 Tick
 108 PhysicalMemory::calculateLatency(Packet *pkt)
 109 {
 110     return lat;
 111 }
 112
 113 void
 114 PhysicalMemory::doFunctionalAccess(Packet *pkt)
 115 {
 116     assert(pkt->getAddr() + pkt->getSize() < params()->addrRange.size());
 117
 118     switch (pkt->cmd) {
 119       case Packet::ReadReq:
 120         memcpy(pkt->getPtr<uint8_t>(),
 121                pmemAddr + pkt->getAddr() - params()->addrRange.start,
 122                pkt->getSize());
 123         break;
 124       case Packet::WriteReq:
 125         memcpy(pmemAddr + pkt->getAddr() - params()->addrRange.start,
 126                pkt->getPtr<uint8_t>(),
 127                pkt->getSize());
 128         // temporary hack: will need to add real LL/SC implementation
 129         // for cacheless systems later.
 130         if (pkt->req->getFlags() & LOCKED) {
 131             pkt->req->setScResult(1);
 132         }
 133         break;
 134       default:
 135         panic("unimplemented");
 136     }
 137
 138     pkt->result = Packet::Success;
 139 }
 140
 141 Port *
 142 PhysicalMemory::getPort(const std::string &if_name, int idx)
 143 {
 144     if (if_name == "port" && idx == -1) {
 145         if (port != NULL)
 146            panic("PhysicalMemory::getPort: additional port requested to memory!");
 147         port = new MemoryPort(name() + "-port", this);
 148         return port;
 149     } else if (if_name == "functional") {
 150         /* special port for functional writes at startup. */
 151         return new MemoryPort(name() + "-funcport", this);
 152     } else {
 153         panic("PhysicalMemory::getPort: unknown port %s requested", if_name);
 154     }
 155 }
 156
 157 void
 158 PhysicalMemory::recvStatusChange(Port::Status status)
 159 {
 160 }
 161
 162 PhysicalMemory::MemoryPort::MemoryPort(const std::string &_name,
 163                                        PhysicalMemory *_memory)
 164     : SimpleTimingPort(_name), memory(_memory)
 165 { }
 166
 167 void
 168 PhysicalMemory::MemoryPort::recvStatusChange(Port::Status status)
 169 {
 170     memory->recvStatusChange(status);
 171 }
 172
 173 void
 174 PhysicalMemory::MemoryPort::getDeviceAddressRanges(AddrRangeList &resp,
 175                                             AddrRangeList &snoop)
 176 {
 177     memory->getAddressRanges(resp, snoop);
 178 }
 179
 180 void
 181 PhysicalMemory::getAddressRanges(AddrRangeList &resp, AddrRangeList &snoop)
 182 {
 183     snoop.clear();
 184     resp.clear();
 185     resp.push_back(RangeSize(params()->addrRange.start, params()->addrRange.size()));
 186 }
 187
 188 int
 189 PhysicalMemory::MemoryPort::deviceBlockSize()
 190 {
 191     return memory->deviceBlockSize();
 192 }
 193
 194 bool
 195 PhysicalMemory::MemoryPort::recvTiming(Packet *pkt)
 196 {
 197     assert(pkt->result != Packet::Nacked);
 198
 199     Tick latency = memory->calculateLatency(pkt);
 200
 201     memory->doFunctionalAccess(pkt);
 202
 203     pkt->makeTimingResponse();
 204     sendTiming(pkt, latency);
 205
 206     return true;
 207 }
 208
 209 Tick
 210 PhysicalMemory::MemoryPort::recvAtomic(Packet *pkt)
 211 {
 212     memory->doFunctionalAccess(pkt);
 213     return memory->calculateLatency(pkt);
 214 }
 215
 216 void
 217 PhysicalMemory::MemoryPort::recvFunctional(Packet *pkt)
 218 {
 219     memory->doFunctionalAccess(pkt);
 220 }
 221
 222 unsigned int
 223 PhysicalMemory::drain(Event *de)
 224 {
 225     int count = port->drain(de);
 226     if (count)
 227         changeState(Draining);
 228     else
 229         changeState(Drained);
 230     return count;
 231 }
 232
 233 void
 234 PhysicalMemory::serialize(ostream &os)
 235 {
 236     gzFile compressedMem;
 237     string filename = name() + ".physmem";
 238
 239     SERIALIZE_SCALAR(filename);
 240
 241     // write memory file
 242     string thefile = Checkpoint::dir() + "/" + filename.c_str();
 243     int fd = creat(thefile.c_str(), 0664);
 244     if (fd < 0) {
 245         perror("creat");
 246         fatal("Can't open physical memory checkpoint file '%s'\n", filename);
 247     }
 248
 249     compressedMem = gzdopen(fd, "wb");
 250     if (compressedMem == NULL)
 251         fatal("Insufficient memory to allocate compression state for %s\n",
 252                 filename);
 253
 254     if (gzwrite(compressedMem, pmemAddr, params()->addrRange.size()) != params()->addrRange.size()) {
 255         fatal("Write failed on physical memory checkpoint file '%s'\n",
 256               filename);
 257     }
 258
 259     if (gzclose(compressedMem))
 260         fatal("Close failed on physical memory checkpoint file '%s'\n",
 261               filename);
 262 }
 263
 264 void
 265 PhysicalMemory::unserialize(Checkpoint *cp, const string &section)
 266 {
 267     gzFile compressedMem;
 268     long *tempPage;
 269     long *pmem_current;
 270     uint64_t curSize;
 271     uint32_t bytesRead;
 272     const int chunkSize = 16384;
 273
 274
 275     string filename;
 276
 277     UNSERIALIZE_SCALAR(filename);
 278
 279     filename = cp->cptDir + "/" + filename;
 280
 281     // mmap memoryfile
 282     int fd = open(filename.c_str(), O_RDONLY);
 283     if (fd < 0) {
 284         perror("open");
 285         fatal("Can't open physical memory checkpoint file '%s'", filename);
 286     }
 287
 288     compressedMem = gzdopen(fd, "rb");
 289     if (compressedMem == NULL)
 290         fatal("Insufficient memory to allocate compression state for %s\n",
 291                 filename);
 292
 293     // unmap file that was mmaped in the constructor
 294     // This is done here to make sure that gzip and open don't muck with our
 295     // nice large space of memory before we reallocate it
 296     munmap(pmemAddr, params()->addrRange.size());
 297
 298     pmemAddr = (uint8_t *)mmap(NULL, params()->addrRange.size(), PROT_READ | PROT_WRITE,
 299                                 MAP_ANON | MAP_PRIVATE, -1, 0);
 300
 301     if (pmemAddr == (void *)MAP_FAILED) {
 302         perror("mmap");
 303         fatal("Could not mmap physical memory!\n");
 304     }
 305
 306     curSize = 0;
 307     tempPage = (long*)malloc(chunkSize);
 308     if (tempPage == NULL)
 309         fatal("Unable to malloc memory to read file %s\n", filename);
 310
 311     /* Only copy bytes that are non-zero, so we don't give the VM system hell */
 312     while (curSize < params()->addrRange.size()) {
 313         bytesRead = gzread(compressedMem, tempPage, chunkSize);
 314         if (bytesRead != chunkSize && bytesRead != params()->addrRange.size() - curSize)
 315             fatal("Read failed on physical memory checkpoint file '%s'"
 316                   " got %d bytes, expected %d or %d bytes\n",
 317                   filename, bytesRead, chunkSize, params()->addrRange.size()-curSize);
 318
 319         assert(bytesRead % sizeof(long) == 0);
 320
 321         for (int x = 0; x < bytesRead/sizeof(long); x++)
 322         {
 323              if (*(tempPage+x) != 0) {
 324                  pmem_current = (long*)(pmemAddr + curSize + x * sizeof(long));
 325                  *pmem_current = *(tempPage+x);
 326              }
 327         }
 328         curSize += bytesRead;
 329     }
 330
 331     free(tempPage);
 332
 333     if (gzclose(compressedMem))
 334         fatal("Close failed on physical memory checkpoint file '%s'\n",
 335               filename);
 336
 337 }
 338
 339
 340 BEGIN_DECLARE_SIM_OBJECT_PARAMS(PhysicalMemory)
 341
 342     Param<string> file;
 343     Param<Range<Addr> > range;
 344     Param<Tick> latency;
 345
 346 END_DECLARE_SIM_OBJECT_PARAMS(PhysicalMemory)
 347
 348 BEGIN_INIT_SIM_OBJECT_PARAMS(PhysicalMemory)
 349
 350     INIT_PARAM_DFLT(file, "memory mapped file", ""),
 351     INIT_PARAM(range, "Device Address Range"),
 352     INIT_PARAM(latency, "Memory access latency")
 353
 354 END_INIT_SIM_OBJECT_PARAMS(PhysicalMemory)
 355
 356 CREATE_SIM_OBJECT(PhysicalMemory)
 357 {
 358     PhysicalMemory::Params *p = new PhysicalMemory::Params;
 359     p->name = getInstanceName();
 360     p->addrRange = range;
 361     p->latency = latency;
 362     return new PhysicalMemory(p);
 363 }
 364
 365 REGISTER_SIM_OBJECT("PhysicalMemory", PhysicalMemory)