     typename Value,
     typename SizeT>
 void RunTests(
-    Csr<VertexId, Value, SizeT> &graph,
+    Csr<VertexId, Value, SizeT> *graph,
     CommandLineArgs             &args,
     int                         num_gpus,
     ContextPtr                  *context,
     int                         *gpu_idx,
     cudaStream_t                *streams)
 {
-    VertexId            src                 = -1;           // Use whatever the specified graph-type's default is
-    std::string         src_str;
-    bool                instrumented        = false;        // Whether or not to collect instrumentation from kernels
-    int                 max_grid_size       = 0;            // maximum grid size (0: leave it up to the enactor)
-    //int                 num_gpus            = 1;            // Number of GPUs for multi-gpu enactor to use
-    float               max_queue_sizing    = 1.0;
-    float               max_in_sizing       = 1.0;
-    bool                mark_pred           = false;
-    std::string         partition_method    = "random";
-    int                 iterations          = 1;
-    bool                disable_size_check  = false;
-    int                 delta_factor        = 16;
-    float               partition_factor    = -1;
-    int                 partition_seed      = -1;
-
-    instrumented = args.CheckCmdLineFlag("instrumented");
-    disable_size_check = args.CheckCmdLineFlag("disable-size-check");
+    string src_str = "";
+    Test_Parameter *parameter = new Test_Parameter;
+    
+    parameter -> Init(args);
+    parameter -> graph              = graph;
+    parameter -> num_gpus           = num_gpus;
+    parameter -> context            = context;
+    parameter -> gpu_idx            = gpu_idx;
+    parameter -> streams            = streams;
+
     args.GetCmdLineArgument("src", src_str);
     if (src_str.empty()) {
-        src = 0;
+        parameter->src = 0;
     } else if (src_str.compare("randomize") == 0) {
-        src = graphio::RandomNode(graph.nodes);
+        parameter->src = graphio::RandomNode(graph->nodes);
     } else if (src_str.compare("largestdegree") == 0) {
         int temp;
-        src = graph.GetNodeWithHighestDegree(temp);
+        parameter->src = graph->GetNodeWithHighestDegree(temp);
     } else {
-        args.GetCmdLineArgument("src", src);
-    }
-
-    g_verbose = args.CheckCmdLineFlag("v"        );
-    g_quick   = args.CheckCmdLineFlag("quick"    );
-    mark_pred = args.CheckCmdLineFlag("mark-pred");
-    args.GetCmdLineArgument("iteration-num"   , iterations      );
-    args.GetCmdLineArgument("queue-sizing"    , max_queue_sizing);
-    args.GetCmdLineArgument("in-sizing"       , max_in_sizing   );
-    args.GetCmdLineArgument("grid-size"       , max_grid_size   );
-    args.GetCmdLineArgument("delta-factor"    , delta_factor    );
-    args.GetCmdLineArgument("partition-factor", partition_factor);
-    args.GetCmdLineArgument("partition-seed"  , partition_seed  );
-    if (args.CheckCmdLineFlag  ("partition-method")) 
-        args.GetCmdLineArgument("partition-method",partition_method);
-
-    if (mark_pred) {
-        if (instrumented) {
-            RunTests<VertexId, Value, SizeT, true, true>(
-                    graph,
-                    src,
-                    max_grid_size,
-                    max_queue_sizing,
-                    max_in_sizing,
-                    num_gpus,
-                    delta_factor,
-                    iterations,
-                    context,
-                    partition_method,
-                    gpu_idx,
-                    streams,
-                    !disable_size_check,
-                    partition_factor,
-                    partition_seed);
-        } else {
-            RunTests<VertexId, Value, SizeT, false, true>(
-                    graph,
-                    src,
-                    max_grid_size,
-                    max_queue_sizing,
-                    max_in_sizing,
-                    num_gpus,
-                    delta_factor,
-                    iterations,
-                    context,
-                    partition_method,
-                    gpu_idx,
-                    streams,
-                    !disable_size_check,
-                    partition_factor,
-                    partition_seed);
-        }
-    } else {
-        if (instrumented) {
-            RunTests<VertexId, Value, SizeT, true, false>(
-                    graph,
-                    src,
-                    max_grid_size,
-                    max_queue_sizing,
-                    max_in_sizing,
-                    num_gpus,
-                    delta_factor,
-                    iterations,
-                    context,
-                    partition_method,
-                    gpu_idx,
-                    streams,
-                    !disable_size_check,
-                    partition_factor,
-                    partition_seed);
-        } else {
-            RunTests<VertexId, Value, SizeT, false, false>(
-                    graph,
-                    src,
-                    max_grid_size,
-                    max_queue_sizing,
-                    max_in_sizing,
-                    num_gpus,
-                    delta_factor,
-                    iterations,
-                    context,
-                    partition_method,
-                    gpu_idx,
-                    streams,
-                    !disable_size_check,
-                    partition_factor,
-                    partition_seed);
-        }
-    }
-
+        args.GetCmdLineArgument("src", parameter->src);
+    }
+    printf("src = %lld\n", parameter->src);
+
+    RunTests_instrumented<VertexId, Value, SizeT>(parameter);
 }
 
 

        printf("max degree:%d\n", max_degree);
	
        // Run tests
        RunTests(csr, args, num_gpus, context, gpu_idx, streams);

    } else {
        // Unknown graph type

 * Defines, constants, globals 
 ******************************************************************************/

//bool g_verbose;
//bool g_undirected;
//bool g_quick;
//bool g_stream_from_host;

/******************************************************************************
 * Housekeeping Routines
