pcmsim
==========

A block device driver for Linux that simulates the presence of a Phase Change
Memory (PCM) in the system installed in one of the DIMM slots on the
motherboard. The simulator is implemented as a kernel module for Linux that
creates /dev/pcm0 when it is loaded -- a ramdisk-backed block devices with
latencies that of PCM. 

Original author: Peter Macko <pmacko@eecs.harvard.edu>
Project website: http://code.google.com/p/pcmsim/
Project license: BSD and GPL v. 3 (dual license)


  Compiling and Running pcmsim
--------------------------------

Build the project using the "make" command. Then load the generated kernel
module. This will create /dev/pcm0, which you can then format with your
favorite file system and use for benchmarking. Note that the data are backed
by a RAM disk, which means that all data that you put on the block device
will magically disappear upon reboot or module unload.

When the module is loaded, it will benchmark the performace of RAM on your
computer and compute the differences between the latencies of the RAM disk
and the simulated PCM. To edit the PCM parameters, modify pcm.c directly
(or fix the code and make it configurable). Also, please note that the RAM
benchmarking is not particularly reliable, but it works most of the time at
least for my test machines. Therefore, please make sure to run multiple trials
and then remove the outliers before using your results. Also, if you manage
to fix this, I'll appreciate if you send me a patch.

The pcmsim kernel module has been tested only on selected 2.6.x kernels; it
still needs to be ported to 3.0.x and 3.2.x kernels. If you mange to fix this,
please send me a patch :)


  Using pcmsim
----------------

Please make sure to do the following before you use pcmsim:

1. There are some parameters that are currently hard-coded that you would need
to change to match your specific computer:
        memory_ddr_version
        memory_ddr_rating
        memory_tRCD
        memory_tRP
        memory_tCL10 (this is the value of the CL parameter x 10)
They are defined starting at lines 110 and 563 of memory.c. You should be able
to lookup these values on data sheets of your RAM modules. There might be a few
more hard-coded values in memory.c - please look around to make sure.

2. Edit pcm.c if you wish to change the parameters of the PCM device that you
are simulating.

3. In addition to these parameters, the module benchmarks the rest of the
parameters when it is loaded. Check dmesg for the summary. Try loading and
unloading the module several times to make sure that the numbers are reasonably
stable. After unloading the module, some statistics are printed to dmesg.

Once everything works, load the module. Check dmesg to make sure that the
printed numbers appear reasonable. Then format and mount /dev/pcm0, do your
benchmarks, and umount the disk and unload the module when you are done. Then
check dmesg for a few more statistics.


  Simulator Pseudo-Code
-------------------------

INIT:
  budget := 0
  dirty  := F


READ:
  budget := budget - overhead_time

  if not cached:
    # If the page was dirty, the processor has already performed
    # the write-back, so we can clear the dirty flag.
    budget := budget + read_time
    dirty  := F

  else:
    pass


WRITE:
  budget := budget - overhead_time

  if not cached and not dirty:
    # The processor should perform write-allocate.
    # Account for a write-back that would occur at a later time.
    budget := budget + write_time
    dirty  := T

  elif not cached and dirty:
    # The processor performed a write-back since the last time
    # we accessed the page, so in fact, the page is not dirty.
    # Account for a write-back that would occur at a later time.
    budget := budget + write_time
    dirty  := T
  
  elif cached and not dirty:
    # The data is in cache, but we never wrote since it was first read.
    # Account for a write-back that would occur at a later time.
    budget := budget + write_time
    dirty  := T

  elif cached and dirty:
    # The data has been loaded in the cache, and we've already written to it.
    # There was not write-back since the last time we accessed the page.
    # We have already accounted for the write-back.
    pass