Locking infrastructure helpers
authorBarret Rhoden <brho@cs.berkeley.edu>
Sat, 25 May 2013 22:05:07 +0000 (15:05 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Sat, 25 May 2013 22:09:02 +0000 (15:09 -0700)
This stuff was just used when testing preemption scenarios.  Ideally,
all of it would be in its own C program.  Check out the TODOs at the top
of lockprov.sh for details.

kern/kfs/lockprov.sh
tests/prov.c

index 710e2b7..c5dc334 100644 (file)
@@ -6,7 +6,9 @@
 # TODO: take a param up to MAXVC for how many cores we preempt per loop
 # TODO: make a program that does the preemption, instead of the script.  it
 # takes around 2ms to spawn, run, and wait on a program, which messes with the
-# timing
+# timing.  When we do this, pull in the vcore shuffling code from prov.c and
+# have that be an option.
+# TODO: have better options for the two preempt styles (periodic, vs total)
 
 if [ $# -lt 2 ]
 then
@@ -15,6 +17,7 @@ then
 fi
 
 PREEMPT_DELAY=$1
+
 shift
 
 # for suppressing output later (no /dev/null, and also append doesn't work)
@@ -37,6 +40,8 @@ echo Launch lock_test, pid was $LOCKPID
 # using the retval of prov -p$LOCKPID to tell us if lock_test is around
 RET=0
 INC=0
+
+# This is the preempt, return, preempt return cycle
 while [ $RET -eq 0 ]; do
        prov -tc -p$LOCKPID -m >> tmpfile 2>&1
        RET=$?
@@ -44,12 +49,33 @@ while [ $RET -eq 0 ]; do
        usleep $PREEMPT_DELAY
        
        prov -tc -p$PTHPID -v1 >> tmpfile 2>&1
-       #prov -tc -p$PTHPID -v2 >> tmpfile 2>&1
+       prov -tc -p$PTHPID -v2 >> tmpfile 2>&1
 
        usleep $PREEMPT_DELAY
 
        let INC=$INC+1
 done
 
+## This is the 'run for a bit, preempt a lot just once, then return all style
+#prov -tc -p$LOCKPID -m >> tmpfile 2>&1
+#usleep $PREEMPT_DELAY
+#prov -tc -p$PTHPID -v1 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v2 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v3 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v4 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v5 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v6 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v7 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v8 >> tmpfile 2>&1
+#prov -tc -p$PTHPID -v9 >> tmpfile 2>&1
+#usleep $PREEMPT_DELAY
+#prov -tc -p$LOCKPID -m >> tmpfile 2>&1
+#
+#while [ $RET -eq 0 ]; do
+#      prov -tc -p$LOCKPID -m >> tmpfile 2>&1
+#      RET=$?
+#      usleep $PREEMPT_DELAY
+#done
+
 echo All done, killing pth_test.  Did $INC prov-preempt loops.
 kill -9 $PTHPID
index ce4137b..36d4676 100644 (file)
@@ -131,12 +131,53 @@ static int prov_pid(pid_t pid, struct prog_args *pargs)
                case ('c'):
                        if (pargs->max) {
                                /* TODO: don't guess the LL/CG layout and num pcores */
+                               #if 1
                                for (int i = 1; i < max_vcores() + 1; i++) {
                                        if ((retval = sys_provision(pid, RES_CORES, i))) {
                                                perror("Failed max provisioning");
                                                return retval;
                                        }
                                }
+                               #else
+                               /* To force a vcore shuffle / least optimal ordering, change
+                                * the if 1 to 0.  Normally, we provision out in a predictable,
+                                * VCn->PCn+1 ordering.  This splits the odd and even VCs
+                                * across sockets on a 32 PC machine (c89).  This is only for
+                                * perf debugging, when using the lockprov.sh script. */
+                               retval = 0;
+                               retval |= sys_provision(pid, RES_CORES,  1);
+                               retval |= sys_provision(pid, RES_CORES, 16);
+                               retval |= sys_provision(pid, RES_CORES,  2);
+                               retval |= sys_provision(pid, RES_CORES, 17);
+                               retval |= sys_provision(pid, RES_CORES,  3);
+                               retval |= sys_provision(pid, RES_CORES, 18);
+                               retval |= sys_provision(pid, RES_CORES,  4);
+                               retval |= sys_provision(pid, RES_CORES, 19);
+                               retval |= sys_provision(pid, RES_CORES,  5);
+                               retval |= sys_provision(pid, RES_CORES, 20);
+                               retval |= sys_provision(pid, RES_CORES,  6);
+                               retval |= sys_provision(pid, RES_CORES, 21);
+                               retval |= sys_provision(pid, RES_CORES,  7);
+                               retval |= sys_provision(pid, RES_CORES, 22);
+                               retval |= sys_provision(pid, RES_CORES,  8);
+                               retval |= sys_provision(pid, RES_CORES, 23);
+                               retval |= sys_provision(pid, RES_CORES,  9);
+                               retval |= sys_provision(pid, RES_CORES, 24);
+                               retval |= sys_provision(pid, RES_CORES, 10);
+                               retval |= sys_provision(pid, RES_CORES, 25);
+                               retval |= sys_provision(pid, RES_CORES, 11);
+                               retval |= sys_provision(pid, RES_CORES, 26);
+                               retval |= sys_provision(pid, RES_CORES, 12);
+                               retval |= sys_provision(pid, RES_CORES, 27);
+                               retval |= sys_provision(pid, RES_CORES, 13);
+                               retval |= sys_provision(pid, RES_CORES, 28);
+                               retval |= sys_provision(pid, RES_CORES, 14);
+                               retval |= sys_provision(pid, RES_CORES, 29);
+                               retval |= sys_provision(pid, RES_CORES, 15);
+                               retval |= sys_provision(pid, RES_CORES, 31);
+                               retval |= sys_provision(pid, RES_CORES, 30);
+                               return retval;
+                               #endif
                        } else {
                                if ((retval = sys_provision(pid, RES_CORES, pargs->res_val))) {
                                        perror("Failed single provision");