Initialize project

Author: chrisbeard

Makefile

@@ -0,0 +1,30 @@
+#
+# Students' Makefile for the Malloc Lab
+#
+TEAM = bovik
+VERSION = 1
+HANDINDIR = /afs/cs.cmu.edu/academic/class/15213-f01/malloclab/handin
+
+CC = gcc
+CFLAGS = -Wall -O2 -m32
+
+OBJS = mdriver.o mm.o memlib.o fsecs.o fcyc.o clock.o ftimer.o
+
+mdriver: $(OBJS)
+	$(CC) $(CFLAGS) -o mdriver $(OBJS)
+
+mdriver.o: mdriver.c fsecs.h fcyc.h clock.h memlib.h config.h mm.h
+memlib.o: memlib.c memlib.h
+mm.o: mm.c mm.h memlib.h
+fsecs.o: fsecs.c fsecs.h config.h
+fcyc.o: fcyc.c fcyc.h
+ftimer.o: ftimer.c ftimer.h config.h
+clock.o: clock.c clock.h
+
+handin:
+	cp mm.c $(HANDINDIR)/$(TEAM)-$(VERSION)-mm.c
+
+clean:
+	rm -f *~ *.o mdriver
+
+

Malloc_tutorial.pdf

@@ -0,0 +1,52 @@
+#####################################################################
+# CS:APP Malloc Lab
+# Handout files for students
+#
+# Copyright (c) 2002, R. Bryant and D. O'Hallaron, All rights reserved.
+# May not be used, modified, or copied without permission.
+#
+######################################################################
+
+***********
+Main Files:
+***********
+
+mm.{c,h}	
+	Your solution malloc package. mm.c is the file that you
+	will be handing in, and is the only file you should modify.
+
+mdriver.c	
+	The malloc driver that tests your mm.c file
+
+short{1,2}-bal.rep
+	Two tiny tracefiles to help you get started. 
+
+Makefile	
+	Builds the driver
+
+**********************************
+Other support files for the driver
+**********************************
+
+config.h	Configures the malloc lab driver
+fsecs.{c,h}	Wrapper function for the different timer packages
+clock.{c,h}	Routines for accessing the Pentium and Alpha cycle counters
+fcyc.{c,h}	Timer functions based on cycle counters
+ftimer.{c,h}	Timer functions based on interval timers and gettimeofday()
+memlib.{c,h}	Models the heap and sbrk function
+
+*******************************
+Building and running the driver
+*******************************
+To build the driver, type "make" to the shell.
+
+To run the driver on a tiny test trace:
+
+	unix> mdriver -V -f short1-bal.rep
+
+The -V option prints out helpful tracing and summary information.
+
+To get a list of the driver flags:
+
+	unix> mdriver -h
+

README

@@ -0,0 +1,279 @@
+/* 
+ * clock.c - Routines for using the cycle counters on x86, 
+ *           Alpha, and Sparc boxes.
+ * 
+ * Copyright (c) 2002, R. Bryant and D. O'Hallaron, All rights reserved.
+ * May not be used, modified, or copied without permission.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/times.h>
+#include "clock.h"
+
+
+/******************************************************* 
+ * Machine dependent functions 
+ *
+ * Note: the constants __i386__ and  __alpha
+ * are set by GCC when it calls the C preprocessor
+ * You can verify this for yourself using gcc -v.
+ *******************************************************/
+
+#if defined(__i386__)  
+/*******************************************************
+ * Pentium versions of start_counter() and get_counter()
+ *******************************************************/
+
+
+/* $begin x86cyclecounter */
+/* Initialize the cycle counter */
+static unsigned cyc_hi = 0;
+static unsigned cyc_lo = 0;
+
+
+/* Set *hi and *lo to the high and low order bits  of the cycle counter.  
+   Implementation requires assembly code to use the rdtsc instruction. */
+void access_counter(unsigned *hi, unsigned *lo)
+{
+    asm("rdtsc; movl %%edx,%0; movl %%eax,%1"   /* Read cycle counter */
+	: "=r" (*hi), "=r" (*lo)                /* and move results to */
+	: /* No input */                        /* the two outputs */
+	: "%edx", "%eax");
+}
+
+/* Record the current value of the cycle counter. */
+void start_counter()
+{
+    access_counter(&cyc_hi, &cyc_lo);
+}
+
+/* Return the number of cycles since the last call to start_counter. */
+double get_counter()
+{
+    unsigned ncyc_hi, ncyc_lo;
+    unsigned hi, lo, borrow;
+    double result;
+
+    /* Get cycle counter */
+    access_counter(&ncyc_hi, &ncyc_lo);
+
+    /* Do double precision subtraction */
+    lo = ncyc_lo - cyc_lo;
+    borrow = lo > ncyc_lo;
+    hi = ncyc_hi - cyc_hi - borrow;
+    result = (double) hi * (1 << 30) * 4 + lo;
+    if (result < 0) {
+	fprintf(stderr, "Error: counter returns neg value: %.0f\n", result);
+    }
+    return result;
+}
+/* $end x86cyclecounter */
+
+#elif defined(__alpha)
+
+/****************************************************
+ * Alpha versions of start_counter() and get_counter()
+ ***************************************************/
+
+/* Initialize the cycle counter */
+static unsigned cyc_hi = 0;
+static unsigned cyc_lo = 0;
+
+
+/* Use Alpha cycle timer to compute cycles.  Then use
+   measured clock speed to compute seconds 
+*/
+
+/*
+ * counterRoutine is an array of Alpha instructions to access 
+ * the Alpha's processor cycle counter. It uses the rpcc 
+ * instruction to access the counter. This 64 bit register is 
+ * divided into two parts. The lower 32 bits are the cycles 
+ * used by the current process. The upper 32 bits are wall 
+ * clock cycles. These instructions read the counter, and 
+ * convert the lower 32 bits into an unsigned int - this is the 
+ * user space counter value.
+ * NOTE: The counter has a very limited time span. With a 
+ * 450MhZ clock the counter can time things for about 9 
+ * seconds. */
+static unsigned int counterRoutine[] =
+{
+    0x601fc000u,
+    0x401f0000u,
+    0x6bfa8001u
+};
+
+/* Cast the above instructions into a function. */
+static unsigned int (*counter)(void)= (void *)counterRoutine;
+
+
+void start_counter()
+{
+    /* Get cycle counter */
+    cyc_hi = 0;
+    cyc_lo = counter();
+}
+
+double get_counter()
+{
+    unsigned ncyc_hi, ncyc_lo;
+    unsigned hi, lo, borrow;
+    double result;
+    ncyc_lo = counter();
+    ncyc_hi = 0;
+    lo = ncyc_lo - cyc_lo;
+    borrow = lo > ncyc_lo;
+    hi = ncyc_hi - cyc_hi - borrow;
+    result = (double) hi * (1 << 30) * 4 + lo;
+    if (result < 0) {
+	fprintf(stderr, "Error: Cycle counter returning negative value: %.0f\n", result);
+    }
+    return result;
+}
+
+#else
+
+/****************************************************************
+ * All the other platforms for which we haven't implemented cycle
+ * counter routines. Newer models of sparcs (v8plus) have cycle
+ * counters that can be accessed from user programs, but since there
+ * are still many sparc boxes out there that don't support this, we
+ * haven't provided a Sparc version here.
+ ***************************************************************/
+
+void start_counter()
+{
+    printf("ERROR: You are trying to use a start_counter routine in clock.c\n");
+    printf("that has not been implemented yet on this platform.\n");
+    printf("Please choose another timing package in config.h.\n");
+    exit(1);
+}
+
+double get_counter() 
+{
+    printf("ERROR: You are trying to use a get_counter routine in clock.c\n");
+    printf("that has not been implemented yet on this platform.\n");
+    printf("Please choose another timing package in config.h.\n");
+    exit(1);
+}
+#endif
+
+
+
+
+/*******************************
+ * Machine-independent functions
+ ******************************/
+double ovhd()
+{
+    /* Do it twice to eliminate cache effects */
+    int i;
+    double result;
+
+    for (i = 0; i < 2; i++) {
+	start_counter();
+	result = get_counter();
+    }
+    return result;
+}
+
+/* $begin mhz */
+/* Estimate the clock rate by measuring the cycles that elapse */ 
+/* while sleeping for sleeptime seconds */
+double mhz_full(int verbose, int sleeptime)
+{
+    double rate;
+
+    start_counter();
+    sleep(sleeptime);
+    rate = get_counter() / (1e6*sleeptime);
+    if (verbose) 
+	printf("Processor clock rate ~= %.1f MHz\n", rate);
+    return rate;
+}
+/* $end mhz */
+
+/* Version using a default sleeptime */
+double mhz(int verbose)
+{
+    return mhz_full(verbose, 2);
+}
+
+/** Special counters that compensate for timer interrupt overhead */
+
+static double cyc_per_tick = 0.0;
+
+#define NEVENT 100
+#define THRESHOLD 1000
+#define RECORDTHRESH 3000
+
+/* Attempt to see how much time is used by timer interrupt */
+static void callibrate(int verbose)
+{
+    double oldt;
+    struct tms t;
+    clock_t oldc;
+    int e = 0;
+
+    times(&t);
+    oldc = t.tms_utime;
+    start_counter();
+    oldt = get_counter();
+    while (e <NEVENT) {
+	double newt = get_counter();
+
+	if (newt-oldt >= THRESHOLD) {
+	    clock_t newc;
+	    times(&t);
+	    newc = t.tms_utime;
+	    if (newc > oldc) {
+		double cpt = (newt-oldt)/(newc-oldc);
+		if ((cyc_per_tick == 0.0 || cyc_per_tick > cpt) && cpt > RECORDTHRESH)
+		    cyc_per_tick = cpt;
+		/*
+		  if (verbose)
+		  printf("Saw event lasting %.0f cycles and %d ticks.  Ratio = %f\n",
+		  newt-oldt, (int) (newc-oldc), cpt);
+		*/
+		e++;
+		oldc = newc;
+	    }
+	    oldt = newt;
+	}
+    }
+    if (verbose)
+	printf("Setting cyc_per_tick to %f\n", cyc_per_tick);
+}
+
+static clock_t start_tick = 0;
+
+void start_comp_counter() 
+{
+    struct tms t;
+
+    if (cyc_per_tick == 0.0)
+	callibrate(0);
+    times(&t);
+    start_tick = t.tms_utime;
+    start_counter();
+}
+
+double get_comp_counter() 
+{
+    double time = get_counter();
+    double ctime;
+    struct tms t;
+    clock_t ticks;
+
+    times(&t);
+    ticks = t.tms_utime - start_tick;
+    ctime = time - ticks*cyc_per_tick;
+    /*
+      printf("Measured %.0f cycles.  Ticks = %d.  Corrected %.0f cycles\n",
+      time, (int) ticks, ctime);
+    */
+    return ctime;
+}
+

clock.c

@@ -0,0 +1,22 @@
+/* Routines for using cycle counter */
+
+/* Start the counter */
+void start_counter();
+
+/* Get # cycles since counter started */
+double get_counter();
+
+/* Measure overhead for counter */
+double ovhd();
+
+/* Determine clock rate of processor (using a default sleeptime) */
+double mhz(int verbose);
+
+/* Determine clock rate of processor, having more control over accuracy */
+double mhz_full(int verbose, int sleeptime);
+
+/** Special counters that compensate for timer interrupt overhead */
+
+void start_comp_counter();
+
+double get_comp_counter();