 
     Stats() : name(NULL), rate(), search_depth(), redundant_work(), duty() {}
     Stats(const char *name) : name(name), rate(), search_depth(), redundant_work(), duty() {}
+};
+
+struct Test_Parameter : gunrock::app::TestParameter_Base {
+public:
+    //bool          mark_predecessors ;// Whether or not to mark src-distance vs. parent vertices
+    int delta_factor;
+
+    Test_Parameter()
+    { 
+        delta_factor = 16;
+        mark_predecessors = false;
+    }   
+
+    ~Test_Parameter()
+    {   
+    }   
+
+    void Init(CommandLineArgs &args)
+    {   
+        TestParameter_Base::Init(args);
+        mark_predecessors = args.CheckCmdLineFlag("mark-pred");
+        args.GetCmdLineArgument("delta-factor"    , delta_factor    );
+    }   
 };
 
 /**

    typename Value,
    typename SizeT>
void RunTests(
    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");
    args.GetCmdLineArgument("src", src_str);
    if (src_str.empty()) {
        src = 0;
    } else if (src_str.compare("randomize") == 0) {
        src = graphio::RandomNode(graph.nodes);
    } else if (src_str.compare("largestdegree") == 0) {
        int temp;
        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);
        }
    }

}



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

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

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