ruby: Import ruby and slicc from GEMS

We eventually plan to replace the m5 cache hierarchy with the GEMS
hierarchy, but for now we will make both live alongside eachother.

1 files changed, 270 insertions, 0 deletions

diff --git a/src/mem/ruby/network/orion/power_ll.cc b/src/mem/ruby/network/orion/power_ll.cc
new file mode 100644
index 000000000..3628989d0
--- /dev/null
+++ b/src/mem/ruby/network/orion/power_ll.cc
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*------------------------------------------------------------
+ *  Copyright 1994 Digital Equipment Corporation and Steve Wilton
+ *                         All Rights Reserved
+ *
+ * Permission to use, copy, and modify this software and its documentation is
+ * hereby granted only under the following terms and conditions.  Both the
+ * above copyright notice and this permission notice must appear in all copies
+ * of the software, derivative works or modified versions, and any portions
+ * thereof, and both notices must appear in supporting documentation.
+ *
+ * Users of this software agree to the terms and conditions set forth herein,
+ * and hereby grant back to Digital a non-exclusive, unrestricted, royalty-
+ * free right and license under any changes, enhancements or extensions
+ * made to the core functions of the software, including but not limited to
+ * those affording compatibility with other hardware or software
+ * environments, but excluding applications which incorporate this software.
+ * Users further agree to use their best efforts to return to Digital any
+ * such changes, enhancements or extensions that they make and inform Digital
+ * of noteworthy uses of this software.  Correspondence should be provided
+ * to Digital at:
+ *
+ *                       Director of Licensing
+ *                       Western Research Laboratory
+ *                       Digital Equipment Corporation
+ *                       100 Hamilton Avenue
+ *                       Palo Alto, California  94301
+ *
+ * This software may be distributed (but not offered for sale or transferred
+ * for compensation) to third parties, provided such third parties agree to
+ * abide by the terms and conditions of this notice.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *------------------------------------------------------------*/
+
+#include <math.h>
+#include <assert.h>
+
+#include "parm_technology.hh"
+#include "SIM_port.hh"
+#include "power_static.hh"
+#include "power_ll.hh"
+
+/*----------------------------------------------------------------------*/
+
+double SIM_power_gatecap(double width,double wirelength) /* returns gate capacitance in Farads */
+//double width;         /* gate width in um (length is Leff) */
+//double wirelength;    /* poly wire length going to gate in lambda */
+{
+
+  double overlapCap;
+  double gateCap;
+  double l = 0.1525;
+
+#if defined(Pdelta_w)
+  overlapCap = (width - 2*Pdelta_w) * PCov;
+  gateCap  = ((width - 2*Pdelta_w) * (l * LSCALE - 2*Pdelta_l) *
+                PCg) + 2.0 * overlapCap;
+
+  return gateCap;
+#endif
+  return(width*Leff*PARM_Cgate+wirelength*Cpolywire*Leff * SCALE_T);
+  /* return(width*Leff*PARM_Cgate); */
+  /* return(width*CgateLeff+wirelength*Cpolywire*Leff);*/
+}
+
+
+double SIM_power_gatecappass(double width,double wirelength) /* returns gate capacitance in Farads */
+//double width;           /* gate width in um (length is Leff) */
+//double wirelength;      /* poly wire length going to gate in lambda */
+{
+  return(SIM_power_gatecap(width,wirelength));
+  /* return(width*Leff*PARM_Cgatepass+wirelength*Cpolywire*Leff); */
+}
+
+
+/*----------------------------------------------------------------------*/
+
+/* Routine for calculating drain capacitances.  The draincap routine
+ * folds transistors larger than 10um */
+double SIM_power_draincap(double width,int nchannel,int stack)  /* returns drain cap in Farads */
+//double width;         /* um */
+//int nchannel;         /* whether n or p-channel (boolean) */
+//int stack;            /* number of transistors in series that are on */
+{
+  double Cdiffside,Cdiffarea,Coverlap,cap;
+
+  double overlapCap;
+  double swAreaUnderGate;
+  double area_peri;
+  double diffArea;
+  double diffPeri;
+  double l = 0.4 * LSCALE;
+
+
+  diffArea = l * width;
+  diffPeri = 2 * l + 2 * width;
+
+#if defined(Pdelta_w)
+  if(nchannel == 0) {
+    overlapCap = (width - 2 * Pdelta_w) * PCov;
+    swAreaUnderGate = (width - 2 * Pdelta_w) * PCjswA;
+    area_peri = ((diffArea * PCja)
+                 +  (diffPeri * PCjsw));
+
+    return(stack*(area_peri + overlapCap + swAreaUnderGate));
+  }
+  else {
+    overlapCap = (width - 2 * Ndelta_w) * NCov;
+    swAreaUnderGate = (width - 2 * Ndelta_w) * NCjswA;
+    area_peri = ((diffArea * NCja * LSCALE)
+                 +  (diffPeri * NCjsw * LSCALE));
+
+    return(stack*(area_peri + overlapCap + swAreaUnderGate));
+  }
+#endif
+
+        Cdiffside = (nchannel) ? PARM_Cndiffside : PARM_Cpdiffside;
+        Cdiffarea = (nchannel) ? PARM_Cndiffarea : PARM_Cpdiffarea;
+        Coverlap = (nchannel) ? (PARM_Cndiffovlp+PARM_Cnoxideovlp) :
+                                (PARM_Cpdiffovlp+PARM_Cpoxideovlp);
+        /* calculate directly-connected (non-stacked) capacitance */
+        /* then add in capacitance due to stacking */
+        if (width >= 10) {
+            cap = 3.0*Leff*width/2.0*Cdiffarea + 6.0*Leff*Cdiffside +
+                width*Coverlap;
+            cap += (double)(stack-1)*(Leff*width*Cdiffarea +
+                4.0*Leff*Cdiffside + 2.0*width*Coverlap);
+        } else {
+            cap = 3.0*Leff*width*Cdiffarea + (6.0*Leff+width)*Cdiffside +
+                width*Coverlap;
+            cap += (double)(stack-1)*(Leff*width*Cdiffarea +
+                2.0*Leff*Cdiffside + 2.0*width*Coverlap);
+        }
+        return(cap * SCALE_T);
+}
+
+
+/*----------------------------------------------------------------------*/
+
+/* The following routines estimate the effective resistance of an
+   on transistor as described in the tech report.  The first routine
+   gives the "switching" resistance, and the second gives the
+   "full-on" resistance */
+double SIM_power_transresswitch(double width,int nchannel,int stack)  /* returns resistance in ohms */
+//double width;         /* um */
+//int nchannel;         /* whether n or p-channel (boolean) */
+//int stack;            /* number of transistors in series */
+{
+        double restrans;
+        restrans = (nchannel) ? (Rnchannelstatic):
+                                (Rpchannelstatic);
+        /* calculate resistance of stack - assume all but switching trans
+           have 0.8X the resistance since they are on throughout switching */
+        return((1.0+((stack-1.0)*0.8))*restrans/width);
+}
+
+
+/*----------------------------------------------------------------------*/
+
+double SIM_power_transreson(double width,int nchannel,int stack)  /* returns resistance in ohms */
+//double width;           /* um */
+//int nchannel;           /* whether n or p-channel (boolean) */
+//int stack;              /* number of transistors in series */
+{
+        double restrans;
+        restrans = (nchannel) ? Rnchannelon : Rpchannelon;
+
+      /* calculate resistance of stack.  Unlike transres, we don't
+           multiply the stacked transistors by 0.8 */
+        return(stack*restrans/width);
+}
+
+
+/*----------------------------------------------------------------------*/
+
+/* This routine operates in reverse: given a resistance, it finds
+ * the transistor width that would have this R.  It is used in the
+ * data wordline to estimate the wordline driver size. */
+double SIM_power_restowidth(double res,int nchannel)  /* returns width in um */
+//double res;            /* resistance in ohms */
+//int nchannel;          /* whether N-channel or P-channel */
+{
+   double restrans;
+
+        restrans = (nchannel) ? Rnchannelon : Rpchannelon;
+
+   return(restrans/res);
+}
+
+
+/*----------------------------------------------------------------------*/
+
+double SIM_power_horowitz(double inputramptime,double tf,double vs1,double vs2,int rise)
+//double inputramptime,    /* input rise time */
+  //     tf,               /* time constant of gate */
+    //   vs1,vs2;          /* threshold voltages */
+//int rise;                /* whether INPUT rise or fall (boolean) */
+{
+    double a,b,td;
+
+    a = inputramptime/tf;
+    if (rise==RISE) {
+       b = 0.5;
+       td = tf*sqrt(fabs( log(vs1)*log(vs1)+2*a*b*(1.0-vs1))) +
+            tf*(log(vs1)-log(vs2));
+    } else {
+       b = 0.4;
+       td = tf*sqrt(fabs( log(1.0-vs1)*log(1.0-vs1)+2*a*b*(vs1))) +
+            tf*(log(1.0-vs1)-log(1.0-vs2));
+    }
+
+    return(td);
+}
+
+
+
+
+double SIM_power_driver_size(double driving_cap, double desiredrisetime)
+{
+  double nsize, psize;
+  double Rpdrive;
+
+  Rpdrive = desiredrisetime/(driving_cap*log(PARM_VSINV)*-1.0);
+  psize = SIM_power_restowidth(Rpdrive,PCH);
+  nsize = SIM_power_restowidth(Rpdrive,NCH);
+  if (psize > Wworddrivemax) {
+    psize = Wworddrivemax;
+  }
+  if (psize < 4.0 * LSCALE)
+    psize = 4.0 * LSCALE;
+
+  return (psize);
+}
+
+