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 #include "arch/isa_traits.hh"
  43 #include "base/misc.hh"
  44 #include "config/full_system.hh"
  45 #include "mem/physical.hh"
  46 #include "sim/builder.hh"
  47 #include "sim/eventq.hh"
  48 #include "sim/host.hh"
  49
  50 using namespace std;
  51 using namespace TheISA;
  52
  53 PhysicalMemory::PhysicalMemory(Params *p)
  54     : MemObject(p->name), pmemAddr(NULL), port(NULL), lat(p->latency), _params(p)
  55 {
  56     if (params()->addrRange.size() % TheISA::PageBytes != 0)
  57         panic("Memory Size not divisible by page size\n");
  58
  59     int map_flags = MAP_ANON | MAP_PRIVATE;
  60     pmemAddr = (uint8_t *)mmap(NULL, params()->addrRange.size(), PROT_READ | PROT_WRITE,
  61                                 map_flags, -1, 0);
  62
  63     if (pmemAddr == (void *)MAP_FAILED) {
  64         perror("mmap");
  65         fatal("Could not mmap!\n");
  66     }
  67
  68     pagePtr = 0;
  69 }
  70
  71 void
  72 PhysicalMemory::init()
  73 {
  74     if (!port)
  75         panic("PhysicalMemory not connected to anything!");
  76     port->sendStatusChange(Port::RangeChange);
  77 }
  78
  79 PhysicalMemory::~PhysicalMemory()
  80 {
  81     if (pmemAddr)
  82         munmap(pmemAddr, params()->addrRange.size());
  83     //Remove memPorts?
  84 }
  85
  86 Addr
  87 PhysicalMemory::new_page()
  88 {
  89     Addr return_addr = pagePtr << LogVMPageSize;
  90     return_addr += params()->addrRange.start;
  91
  92     ++pagePtr;
  93     return return_addr;
  94 }
  95
  96 int
  97 PhysicalMemory::deviceBlockSize()
  98 {
  99     //Can accept anysize request
 100     return 0;
 101 }
 102
 103 Tick
 104 PhysicalMemory::calculateLatency(Packet *pkt)
 105 {
 106     return lat;
 107 }
 108
 109
 110
 111 // Add load-locked to tracking list.  Should only be called if the
 112 // operation is a load and the LOCKED flag is set.
 113 void
 114 PhysicalMemory::trackLoadLocked(Request *req)
 115 {
 116     Addr paddr = LockedAddr::mask(req->getPaddr());
 117
 118     // first we check if we already have a locked addr for this
 119     // xc.  Since each xc only gets one, we just update the
 120     // existing record with the new address.
 121     list<LockedAddr>::iterator i;
 122
 123     for (i = lockedAddrList.begin(); i != lockedAddrList.end(); ++i) {
 124         if (i->matchesContext(req)) {
 125             DPRINTF(LLSC, "Modifying lock record: cpu %d thread %d addr %#x\n",
 126                     req->getCpuNum(), req->getThreadNum(), paddr);
 127             i->addr = paddr;
 128             return;
 129         }
 130     }
 131
 132     // no record for this xc: need to allocate a new one
 133     DPRINTF(LLSC, "Adding lock record: cpu %d thread %d addr %#x\n",
 134             req->getCpuNum(), req->getThreadNum(), paddr);
 135     lockedAddrList.push_front(LockedAddr(req));
 136 }
 137
 138
 139 // Called on *writes* only... both regular stores and
 140 // store-conditional operations.  Check for conventional stores which
 141 // conflict with locked addresses, and for success/failure of store
 142 // conditionals.
 143 bool
 144 PhysicalMemory::checkLockedAddrList(Request *req)
 145 {
 146     Addr paddr = LockedAddr::mask(req->getPaddr());
 147     bool isLocked = req->isLocked();
 148
 149     // Initialize return value.  Non-conditional stores always
 150     // succeed.  Assume conditional stores will fail until proven
 151     // otherwise.
 152     bool success = !isLocked;
 153
 154     // Iterate over list.  Note that there could be multiple matching
 155     // records, as more than one context could have done a load locked
 156     // to this location.
 157     list<LockedAddr>::iterator i = lockedAddrList.begin();
 158
 159     while (i != lockedAddrList.end()) {
 160
 161         if (i->addr == paddr) {
 162             // we have a matching address
 163
 164             if (isLocked && i->matchesContext(req)) {
 165                 // it's a store conditional, and as far as the memory
 166                 // system can tell, the requesting context's lock is
 167                 // still valid.
 168                 DPRINTF(LLSC, "StCond success: cpu %d thread %d addr %#x\n",
 169                         req->getCpuNum(), req->getThreadNum(), paddr);
 170                 success = true;
 171             }
 172
 173             // Get rid of our record of this lock and advance to next
 174             DPRINTF(LLSC, "Erasing lock record: cpu %d thread %d addr %#x\n",
 175                     i->cpuNum, i->threadNum, paddr);
 176             i = lockedAddrList.erase(i);
 177         }
 178         else {
 179             // no match: advance to next record
 180             ++i;
 181         }
 182     }
 183
 184     if (isLocked) {
 185         req->setScResult(success ? 1 : 0);
 186     }
 187
 188     return success;
 189 }
 190
 191 void
 192 PhysicalMemory::doFunctionalAccess(Packet *pkt)
 193 {
 194     assert(pkt->getAddr() + pkt->getSize() <= params()->addrRange.size());
 195
 196     if (pkt->isRead()) {
 197         if (pkt->req->isLocked()) {
 198             trackLoadLocked(pkt->req);
 199         }
 200         DPRINTF(MemoryAccess, "Performing Read of size %i on address 0x%x\n",
 201                 pkt->getSize(), pkt->getAddr());
 202         memcpy(pkt->getPtr<uint8_t>(),
 203                pmemAddr + pkt->getAddr() - params()->addrRange.start,
 204                pkt->getSize());
 205     }
 206     else if (pkt->isWrite()) {
 207         if (writeOK(pkt->req)) {
 208             DPRINTF(MemoryAccess, "Performing Write of size %i on address 0x%x\n",
 209                     pkt->getSize(), pkt->getAddr());
 210             memcpy(pmemAddr + pkt->getAddr() - params()->addrRange.start,
 211                    pkt->getPtr<uint8_t>(), pkt->getSize());
 212         }
 213     }
 214     else if (pkt->isInvalidate()) {
 215         //upgrade or invalidate
 216         pkt->flags |= SATISFIED;
 217     }
 218     else {
 219         panic("unimplemented");
 220     }
 221
 222     pkt->result = Packet::Success;
 223 }
 224
 225 Port *
 226 PhysicalMemory::getPort(const std::string &if_name, int idx)
 227 {
 228     if (if_name == "port" && idx == -1) {
 229         if (port != NULL)
 230            panic("PhysicalMemory::getPort: additional port requested to memory!");
 231         port = new MemoryPort(name() + "-port", this);
 232         return port;
 233     } else if (if_name == "functional") {
 234         /* special port for functional writes at startup. And for memtester */
 235         return new MemoryPort(name() + "-funcport", this);
 236     } else {
 237         panic("PhysicalMemory::getPort: unknown port %s requested", if_name);
 238     }
 239 }
 240
 241 void
 242 PhysicalMemory::recvStatusChange(Port::Status status)
 243 {
 244 }
 245
 246 PhysicalMemory::MemoryPort::MemoryPort(const std::string &_name,
 247                                        PhysicalMemory *_memory)
 248     : SimpleTimingPort(_name), memory(_memory)
 249 { }
 250
 251 void
 252 PhysicalMemory::MemoryPort::recvStatusChange(Port::Status status)
 253 {
 254     memory->recvStatusChange(status);
 255 }
 256
 257 void
 258 PhysicalMemory::MemoryPort::getDeviceAddressRanges(AddrRangeList &resp,
 259                                             AddrRangeList &snoop)
 260 {
 261     memory->getAddressRanges(resp, snoop);
 262 }
 263
 264 void
 265 PhysicalMemory::getAddressRanges(AddrRangeList &resp, AddrRangeList &snoop)
 266 {
 267     snoop.clear();
 268     resp.clear();
 269     resp.push_back(RangeSize(params()->addrRange.start,
 270                              params()->addrRange.size()));
 271 }
 272
 273 int
 274 PhysicalMemory::MemoryPort::deviceBlockSize()
 275 {
 276     return memory->deviceBlockSize();
 277 }
 278
 279 Tick
 280 PhysicalMemory::MemoryPort::recvAtomic(Packet *pkt)
 281 {
 282     memory->doFunctionalAccess(pkt);
 283     return memory->calculateLatency(pkt);
 284 }
 285
 286 void
 287 PhysicalMemory::MemoryPort::recvFunctional(Packet *pkt)
 288 {
 289     // Default implementation of SimpleTimingPort::recvFunctional()
 290     // calls recvAtomic() and throws away the latency; we can save a
 291     // little here by just not calculating the latency.
 292     memory->doFunctionalAccess(pkt);
 293 }
 294
 295 unsigned int
 296 PhysicalMemory::drain(Event *de)
 297 {
 298     int count = port->drain(de);
 299     if (count)
 300         changeState(Draining);
 301     else
 302         changeState(Drained);
 303     return count;
 304 }
 305
 306 void
 307 PhysicalMemory::serialize(ostream &os)
 308 {
 309     gzFile compressedMem;
 310     string filename = name() + ".physmem";
 311
 312     SERIALIZE_SCALAR(filename);
 313
 314     // write memory file
 315     string thefile = Checkpoint::dir() + "/" + filename.c_str();
 316     int fd = creat(thefile.c_str(), 0664);
 317     if (fd < 0) {
 318         perror("creat");
 319         fatal("Can't open physical memory checkpoint file '%s'\n", filename);
 320     }
 321
 322     compressedMem = gzdopen(fd, "wb");
 323     if (compressedMem == NULL)
 324         fatal("Insufficient memory to allocate compression state for %s\n",
 325                 filename);
 326
 327     if (gzwrite(compressedMem, pmemAddr, params()->addrRange.size()) != params()->addrRange.size()) {
 328         fatal("Write failed on physical memory checkpoint file '%s'\n",
 329               filename);
 330     }
 331
 332     if (gzclose(compressedMem))
 333         fatal("Close failed on physical memory checkpoint file '%s'\n",
 334               filename);
 335 }
 336
 337 void
 338 PhysicalMemory::unserialize(Checkpoint *cp, const string &section)
 339 {
 340     gzFile compressedMem;
 341     long *tempPage;
 342     long *pmem_current;
 343     uint64_t curSize;
 344     uint32_t bytesRead;
 345     const int chunkSize = 16384;
 346
 347
 348     string filename;
 349
 350     UNSERIALIZE_SCALAR(filename);
 351
 352     filename = cp->cptDir + "/" + filename;
 353
 354     // mmap memoryfile
 355     int fd = open(filename.c_str(), O_RDONLY);
 356     if (fd < 0) {
 357         perror("open");
 358         fatal("Can't open physical memory checkpoint file '%s'", filename);
 359     }
 360
 361     compressedMem = gzdopen(fd, "rb");
 362     if (compressedMem == NULL)
 363         fatal("Insufficient memory to allocate compression state for %s\n",
 364                 filename);
 365
 366     // unmap file that was mmaped in the constructor
 367     // This is done here to make sure that gzip and open don't muck with our
 368     // nice large space of memory before we reallocate it
 369     munmap(pmemAddr, params()->addrRange.size());
 370
 371     pmemAddr = (uint8_t *)mmap(NULL, params()->addrRange.size(), PROT_READ | PROT_WRITE,
 372                                 MAP_ANON | MAP_PRIVATE, -1, 0);
 373
 374     if (pmemAddr == (void *)MAP_FAILED) {
 375         perror("mmap");
 376         fatal("Could not mmap physical memory!\n");
 377     }
 378
 379     curSize = 0;
 380     tempPage = (long*)malloc(chunkSize);
 381     if (tempPage == NULL)
 382         fatal("Unable to malloc memory to read file %s\n", filename);
 383
 384     /* Only copy bytes that are non-zero, so we don't give the VM system hell */
 385     while (curSize < params()->addrRange.size()) {
 386         bytesRead = gzread(compressedMem, tempPage, chunkSize);
 387         if (bytesRead != chunkSize && bytesRead != params()->addrRange.size() - curSize)
 388             fatal("Read failed on physical memory checkpoint file '%s'"
 389                   " got %d bytes, expected %d or %d bytes\n",
 390                   filename, bytesRead, chunkSize, params()->addrRange.size()-curSize);
 391
 392         assert(bytesRead % sizeof(long) == 0);
 393
 394         for (int x = 0; x < bytesRead/sizeof(long); x++)
 395         {
 396              if (*(tempPage+x) != 0) {
 397                  pmem_current = (long*)(pmemAddr + curSize + x * sizeof(long));
 398                  *pmem_current = *(tempPage+x);
 399              }
 400         }
 401         curSize += bytesRead;
 402     }
 403
 404     free(tempPage);
 405
 406     if (gzclose(compressedMem))
 407         fatal("Close failed on physical memory checkpoint file '%s'\n",
 408               filename);
 409
 410 }
 411
 412
 413 BEGIN_DECLARE_SIM_OBJECT_PARAMS(PhysicalMemory)
 414
 415     Param<string> file;
 416     Param<Range<Addr> > range;
 417     Param<Tick> latency;
 418
 419 END_DECLARE_SIM_OBJECT_PARAMS(PhysicalMemory)
 420
 421 BEGIN_INIT_SIM_OBJECT_PARAMS(PhysicalMemory)
 422
 423     INIT_PARAM_DFLT(file, "memory mapped file", ""),
 424     INIT_PARAM(range, "Device Address Range"),
 425     INIT_PARAM(latency, "Memory access latency")
 426
 427 END_INIT_SIM_OBJECT_PARAMS(PhysicalMemory)
 428
 429 CREATE_SIM_OBJECT(PhysicalMemory)
 430 {
 431     PhysicalMemory::Params *p = new PhysicalMemory::Params;
 432     p->name = getInstanceName();
 433     p->addrRange = range;
 434     p->latency = latency;
 435     return new PhysicalMemory(p);
 436 }
 437
 438 REGISTER_SIM_OBJECT("PhysicalMemory", PhysicalMemory)