Index: tests/unified_locking/locks.cfa
===================================================================
--- tests/unified_locking/locks.cfa	(revision 441a6a7b3275ed6c7fdb8c499f947eb9de0c8e1e)
+++ tests/unified_locking/locks.cfa	(revision 0cee08241f16adbb0f3a0ecbd211d8152abc1d6c)
@@ -15,6 +15,6 @@
 condition_variable( owner_lock ) c_o;
 
-linear_backoff_then_block_lock l;
-condition_variable( linear_backoff_then_block_lock ) c_l;
+exp_backoff_then_block_lock l;
+condition_variable( exp_backoff_then_block_lock ) c_l;
 
 fast_block_lock f;
Index: tests/unified_locking/thread_test.cfa
===================================================================
--- tests/unified_locking/thread_test.cfa	(revision 441a6a7b3275ed6c7fdb8c499f947eb9de0c8e1e)
+++ tests/unified_locking/thread_test.cfa	(revision 0cee08241f16adbb0f3a0ecbd211d8152abc1d6c)
@@ -25,9 +25,9 @@
 
 thread worker {
-    linear_backoff_then_block_lock * locks;
+    exp_backoff_then_block_lock * locks;
     bool improved;
 };
 
-void ?{}( worker & w, linear_backoff_then_block_lock * locks, bool improved ) {
+void ?{}( worker & w, exp_backoff_then_block_lock * locks, bool improved ) {
 	w.locks = locks;
     w.improved = improved;
@@ -39,5 +39,5 @@
     for (int i = 0; i < workBufferSize; i += 1) buffer[i] = rand() % 1024;
     unsigned int lck = rand() % lockCount;
-    linear_backoff_then_block_lock * curr_lock = &locks[lck];
+    exp_backoff_then_block_lock * curr_lock = &locks[lck];
     for (unsigned int i = 0; i < num_times; i++) {
         dowork(buffer, work_unlocked);
@@ -51,13 +51,15 @@
 }
 
-
+int doOne = 0;
 int main(int argc, char* argv[]) {
     switch (argc) {
+        case 8:
+            doOne = atoi(argv[7]);
         case 7:
-            work_unlocked = atoi(argv[5]);
+            work_unlocked = atoi(argv[6]);
         case 6:
             work_locked = atoi(argv[5]);
         case 5:
-            num_times = atoi(argv[4]);
+            total_times = atoi(argv[4]);
         case 4:
             lockCount = atoi(argv[3]);
@@ -72,10 +74,12 @@
     }
 	processor p[threadCount];
-    linear_backoff_then_block_lock locks[lockCount];
+    exp_backoff_then_block_lock locks[lockCount];
     worker * worker_arr[taskCount];
     num_times = total_times  / taskCount;
-
-	//printf("Start Test: martin lock simple\n");
-	clock_t begin = clock();
+    //printf("%d\n", doOne);
+	//
+	//clock_t begin = clock();
+    if (doOne == 1) {
+        printf("Start Test: martin lock simple %d\n", num_times);
 	for (unsigned int i = 0; i < taskCount; i++) {
         worker_arr[i] = new( locks, false );
@@ -84,10 +88,12 @@
         delete( worker_arr[i] );
     }
-	clock_t end = clock();
-	double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
-	printf("norm: %f\n", time_spent);
+    }
+	//clock_t end = clock();
+	//double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+	//printf("norm: %f\n", time_spent);
 
     //printf("Start Test: martin lock improved\n");
-	begin = clock();
+	//begin = clock();
+    if (doOne == 2) {
 	for (unsigned int i = 0; i < taskCount; i++) {
         worker_arr[i] = new( locks, true );
@@ -96,6 +102,7 @@
         delete( worker_arr[i] );
     }
-	end = clock();
-	time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
-	printf("improved: %f\n", time_spent);
+    }
+	//end = clock();
+	//time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+	//printf("improved: %f\n", time_spent);
 }