#! /usr/sbin/smake 
# --------------------------------------------------------------------
# Basic Makefile for a program composed of Fortran and C modules
# --------------------------------------------------------------------
# The following variables specify the compiler and linker options,
# assembling them by groups for use in later commands. You may
# need to edit these lines several times while tuning.
#
#  -- flags related to ISA, ABI, and model (ipxx) go to $ARCH
#     -- set -n32 or -64. -TARG, -TENV could go here too.
ABI     = -n32
#     -- probably -mips4
ISA     = -mips4 -r10000
#     -- ip27 for Origin2000/Onyx2
PROC    = ip27 
ARCH    = $(ABI) $(ISA)
#  -- flags related to optimization level go to $OPT
#     -- set level, e.g. -O0 g3, -O3, -Ofast=$(PROC) 
OLEVEL  = -O2
#     -- set -OPT: option group
OOPT    = -OPT:alias=restrict
#     -- set -IPA: option group
OIPA    = 
#     -- set -LNO: option group
OLNO    = 
OPT     = $(OLEVEL) $(OOPT) $(OIPA) $(OLNO)
# -- flags related to numeric precision, by compiler
FOPTS   = -OPT:IEEE_arithmetic=3:roundoff=2 
COPTS   = -OPT:IEEE_arithmetic=3:roundoff=2 
# Assemble the f77 and cc flags into single variables
FFLAGS  = $(ARCH) $(OPT) $(FOPTS) 
CFLAGS  = $(ARCH) $(OPT) $(COPTS) 
# Link-time flags must include ABI, ISA, and opt flags
LDFLAGS = $(ARCH) $(OPT) 
# --------------------------------------------------------------------
# The following variables specify the program components.
# You typically edit these lines only once, to specify the modules.
#
#   -- Specify the name of the executable program:
EXEC    = execname 
#   -- list all Fortran object files, e.g. FOBJS = f1.o f2.o
FOBJS   =  
#   -- list all C object files, e.g. COBJS = c1.o c2.o c3.o
COBJS   = 
#   -- List all linked libs
LIBS    = -lfastm -lm
# The program comprises the following object files:
OBJS    = $(FOBJS) $(COBJS) 
# --------------------------------------------------------------------
# The following variables locate tools based on an environment
# variable (or command-line argument) $TOOLROOT.
FC      = $(TOOLROOT)/usr/bin/f77 
CC      = $(TOOLROOT)/usr/bin/cc 
LD      = $(FC) 
F77     = $(FC)
# Locate a script that processes the .S output files
SWP     = swplist 
# Shorthand for "rm" for use in "make clean"
RM      = /bin/rm -f 
# --------------------------------------------------------------------
# Nothing below this point should need editing.
# --------------------------------------------------------------------
# The following target implements "make clean"
clean: 
        $(RM) $(EXEC) $(OBJS) 
# --------------------------------------------------------------------
# The following target implements "make execname" by linking all
# all object files:
$(EXEC):        $(OBJS) 
        $(LD) -o $@ $(LDFLAGS) $(OBJS) $(LIBS) 
# --------------------------------------------------------------------
# The following targets tell how to compile objects from sources.
# Variable $DEFINES is set on the make command line, if at all.
.SUFFIXES: .o .F .c .f .swp 
.F.o: 
        $(FC)  -c $(FFLAGS) $(DEFINES) $< 
.f.o: 
        $(FC)  -c $(FFLAGS) $(DEFINES) $< 
.c.o: 
        $(CC)  -c $(CFLAGS) $(DEFINES) $< 
# --------------------------------------------------------------------
# The following targets implement "make sourcename.swp" to inspect
# the SWP code generation (requires swplist script)
.F.swp: 
        $(SWP) -c $(FFLAGS) $(DEFINES) -WK,-cmp=$*.m $< 
.f.swp: 
        $(SWP) -c $(FFLAGS) $(DEFINES) -WK,-cmp=$*.m $< 
.c.swp: 
        $(SWP) -c $(CFLAGS) $(DEFINES) $< 

#!/bin/csh -f
if ( $#argv == 0 ) then
    echo ""
    echo "Usage: $0 [compiler flags] files..."
    echo "    This version of the script uses the Environment variable"
    echo "    TOOLROOT if set."
    echo "    All tools are called as "\$"TOOLROOT/usr/bin/<tool>."
    exit
endif
set t = /usr/tmp
if (${?TMPDIR}) then
   if (-e ${TMPDIR}) then
      set t = ${TMPDIR}
   endif
endif
if ( ! $?TOOLROOT ) then
    setenv TOOLROOT /
endif
echo 'TOOLROOT is "'$TOOLROOT'"'

set nawk_file1 = $t/$$.SWP.NAWK_1
set nawk_file2 = $t/$$.SWP.NAWK_2
# First awk program extracts SWP descriptive lines and saves
# in temp files, one per loop. Output is a list of loop-files.
cat << NAWK_FILE1_END > $nawk_file1
BEGIN {
        Loop = 0;
        GotLine = 0;
        LoopID = 0;
        TmpFileRoot = sprintf("$t/%s_SWP",FILENAME)
}
/#<swps>/ || /#<swpf>/ {
        if (Loop == 0) {
            Loop = 1; 
            LoopID++; 
            TmpFile = TmpFileRoot"."LoopID;
        }
        print > TmpFile;
}
/oop line/ {
        if (Loop == 1) {
                if (GotLine == 0) {
                        GotLine = 1;
                        split(\$0, Line);
                        i=0;
                        while (Line[i] != "line") {i++}
                        LoopLine = Line[++i];
                        print LoopLine " " TmpFile 
                }
        }
}
!/#<swps>/ && !/#<swpf>/ {
        if (Loop == 1) {
                Loop = 0; 
                GotLine = 0;
                close(TmpFile)
        }
}
END {
    if (Loop == 1) close(TmpFile)
}
NAWK_FILE1_END
# Second awk program 
cat << NAWK_FILE2_END > $nawk_file2
BEGIN {
    CurrentLine = 1
    TmpFileRoot = sprintf("$t/%s_SWP",FILENAME)
    Name = substr(FILENAME, 1, length(FILENAME)-3)
    SortInp = Name".sort"
    OutFile = Name".swp"; system("rm -f "OutFile);
    while ( (getline pair < SortInp) != 0 ) {
        split(pair,rec);
        NextLine = rec[1];
        NextInpFile = rec[2];
        while ( CurrentLine < NextLine ) {
            getline;
            print >> OutFile;
            ++CurrentLine;
        }
        system("cat " NextInpFile " >> " OutFile);
        system("rm " NextInpFile);
    }
}
{
    print >> OutFile;
}
END {
    system("rm " SortInp);
}
NAWK_FILE2_END
# compile all modules with -S given flags and modules specified
${TOOLROOT}/usr/bin/f77 -S $*
# for each module named on command line, process the output
set narg = $#argv
@ i = 1
while ($i <= $narg)
        if (($argv[$i]:e == f) || ($argv[$i]:e == F) || ($argv[$i]:e == c)) then
#           This guards against interpreting flags such as -WK,-inff=file.f
#           as files to compile.
if (-e $argv[$i]) then
                set s = $argv[$i]:r
                pr -t -n10 $argv[$i] > $s.pr
                nawk -f $nawk_file1 $s.s | sort -n > $s.sort
                nawk -f $nawk_file2 $s.pr
                /bin/rm $s.pr
            endif
        endif
        @ i = $i + 1
end
/bin/rm $nawk_file1
/bin/rm $nawk_file2

#!/bin/csh
# script to ssrun a program with designated output dir/filename.
# if no arguments, document usage
if (0 == $#argv) then
echo "$0 [-d output_dir] [-o output_file] [-ssrun_opts] prog_and_args"
   exit -1
endif
# initialize operands
set ssopts = ""
set otdir = "."
set otfile = ""
set proggy = ""
# collect -d, -o, and -ssrun options. Upon encountering name
# of program, break out of the loop, leaving $argv == prog_and_args
while ($#argv > 0)
   switch ($1)
   case "-o"
      setenv _SPEEDSHOP_OUTPUT_FILENAME $2
      set otfile = $2
      shift
      breaksw
   case "-d"
      setenv _SPEEDSHOP_OUTPUT_DIRECTORY $2
      set otdir = $2
      shift
      breaksw
   case "-*"
      set ssopts = ($ssopts $1)
      breaksw
   default
#     # get only tail, allowing ssrun /foo/bar/a.out
      set proggy = ${1}:t
      break
   endsw
   shift
end
# have to have seen a program
if ("X$proggy" == "X") then
   echo you must name a subject program
   exit -2
endif
# default the experiment type
if ("X$ssopts" == "X") then
   set ssopts = -usertime
endif
# run the experiment
echo ssrun $ssopts $argv....
ssrun $ssopts $argv
echo ...... ssrun ends.
# display all the output files with names starting $proggy
if ("X$otfile" == "X") then
#  # outfile not given, file is name.exptype.xpid
   ls -l $otdir/$proggy.*.?[0-9][0-9][0-9]*
else
#  # outfile given, file is name.xpid
   ls -l $otdir/$otfile.*
endif

# Reads output of perfex -a [-y]. Prints selected, reordered counters
# interpolating calculated ratios and percents.  Perfex runs of short
# programs often have zero values for some counts - allow for these.
BEGIN {
  maxline = 0 # track highest counter value seen
  mhz = 200 # assumed MHZ, adjust as needed
}
$0 ~ /^[ 123][0-9] / { # perfex data line
  lines[$1] = $0                 # save the whole line
  counter[$1] = $NF              # save reported value
  if (maxline < $1) maxline = $1 # note high line# seen
}
END { # at end, print report
  if (maxline >=31)
  {
    print lines[0]
    seconds = counter[0]/(mhz*1000000)
    print "   " seconds " seconds elapsed at " mhz "MHZ"
    print lines[17]
    if (counter[17])
    {
      print "   " counter[0]/counter[17] " cycles/graduated instruction"
      print "   " (counter[17]/seconds)/1000000 " MIPS at 200MHZ"
      print lines[18]
      print lines[19]
      if (counter[18]*counter[19])
      {
        print "   " (counter[17]-counter[18])/counter[18] " instructions/load"
        print "   " (counter[17]-counter[19])/counter[19] " instructions/store"
        print "   " counter[18]/counter[19] " loads/store"
      }
      print lines[21]
      if (counter[21])
      {
        print "   " int((counter[21]/counter[17])*100) "% fp instructions"
      }
    }
    print lines[6]
    print lines[24]
    if (counter[6]*counter[24])
    {
      print "   " int((counter[24]/counter[6])*100) "% branches mispredicted"
    }
    print lines[23]
    if (counter[17]*counter[23])
    {
      print "   " counter[17]/counter[23] " instructions/TLB miss"
    }
    print lines[9]
    if (counter[17]*counter[9])
    {
      print "   " counter[17]/counter[9] " instructions/i-L1 miss"
    }
    print lines[10]
    print lines[11]
    if (counter[17]*counter[10])
    {
      print "   " counter[17]/counter[10] " instructions/i-L2 miss"
    }
    print lines[25]
    if (counter[17]*counter[25])
    {
      print "   " counter[17]/counter[25] " instructions/d-L1 miss"
    }
    print lines[26]
    print lines[27]
    if (counter[17]*counter[25])
    {
      print "   " counter[17]/counter[26] " instructions/d-L2 miss"
    }
    smiss = counter[10]+counter[26]
    print "   " smiss " total L2 misses, " 128*smiss " bytes from memory"
    print "       " int(((128*smiss)/seconds)/1024) \
  " KB/sec memory bandwidth use at " mhz "MHZ"
    print lines[22]
    print lines[7]
    print lines[30]
    print lines[31]
    }
    else print "incomplete input"
}

# amdahl.awk: an input line is a series of execution times
# T(1), T(2),...T(N) for a program run with 1, 2, ... N CPUs.
# Use 0 for an unknown time.  T(1) and T(N) must be nonzero.
# For example, after test with 1, 2, and 4 CPUs, you could enter
#           240 190 0 75
# to show those times, with 0 for the unknown time T(3).

{ 
   # save times T(n) in array t[]
   for (j=1;j<=NF;++j) t[j] = $j 
   # calculate p, parallel fraction of code
   if (2==NF) 
   {  # use simple formula for p given only T1, T2 
      s2 = t[1]/t[2] 
      p = 2*(s2-1)/s2 
   } 
   else 
   {  # use general formula on the last 2 nonzero inputs
      for (m=NF-1; t[m]==0; --m) ;
      sm = t[1]/t[m] 
      sn = t[1]/t[NF] 
      invm = 1/m 
      invn = 1/NF 
      p = (sm - sn)/( sm*(1-invm) - sn*(1-invn) ) 
   } 
   if (p<1) 
   { 
      printf("#CPUs   SpeedUp(n)    T(n)     p=%6.3g\n",p) 
      npat = "%5d   %6.3g    %8.3g\n" 
      # print the actual times as given and their speedups 
      printf(npat,1,1.0,t[1]) 
      for (j=2;j<=NF;++j) 
      { 
         if (t[j]) printf(npat,j,t[1]/t[j],t[j]) 
      } 
      # extrapolate using amdahl's law based on calculated p 
      # first, for CPUs one at a time to 7 
      for (j=NF+1;j<8;++j) 
      { 
         sj = 1/((p/j)+(1-p)) 
         printf(npat,j,sj,t[1]/sj) 
      } 
      # then 8, 16, 32, 64 and 128 
      for (j=8;j<=128;j=j+j) 
      { 
        sj = 1/((p/j)+(1-p)) 
        if (j>NF) printf(npat,j,sj,t[1]/sj) 
      } 
   } 
   else 
   { 
      printf("p=%6.3g, hyperlinear speedup\n",p) 
      printf("Enter a list of times for more more than %d CPUs\n\n",NF) 
   } 
} 

#include <stdio.h>
#include <sys/types.h>
#include <sys/syssgi.h>
__uint64_t
va2pa( void *va)
{
   __uint64_t   pa;
   __uint32_t   pfn;
   int          status;
   static int   lpgsz, pgsz = -1;
   if (pgsz < 0) { /* first time: log2(pagesize) */
      int itmp;
      pgsz = itmp = getpagesize();
      for (lpgsz=0; itmp>1; itmp>>=1, lpgsz++);
   }
   if ((status = syssgi(SGI_PHYSP,va,&pfn)) != 0) {
      perror("Virtual to physical mapping failed");
      exit(1);
   }
   pa = (((__uint64_t) pfn << lpgsz) | ((__uint64_t) va & (pgsz-1)));
   return (pa);
}

/* =============================================================
|| Return CPU clock rate in megahertz, by the rather
|| byzantine method of scanning the hardware inventory
*/
#include <invent.h>
#DEFINE DFLT_MHZ 195 /* return if any error */
int cpuclock(void)
{
        inventory_t *p_inv;
        if (setinvent()) return DFLT_MHZ;
        for(p_inv = getinvent(); (p_inv); p_inv = getinvent())
        {
                if (  (p_inv->inv_class == INV_PROCESSOR)
                        &&(p_inv->inv_type == INV_CPUBOARD) )
                break;
        }
        endinvent();
        if (p_inv)
                return p_inv->inv_controller;
        else
                return DFLT_MHZ;
}