File workload_file = this.getWorkloadFile(type);

            assertNotNull(workload_file);

            assert(workload_file.exists());

            workload = new Workload(catalog);

            ((Workload) workload).load(workload_file, catalog_db, filter);

           

            File stats_file = this.getStatsFile(type);

            assertNotNull(stats_file);

            assert(stats_file.exists());

        if (workload == null) {

            File file = this.getWorkloadFile(ProjectType.TPCC);

            workload = new Workload(catalog);

                    .include(TARGET_PROCEDURE.getSimpleName())

                    .attach(new ProcParameterValueFilter().include(1, new Integer(1))) // D_ID

                    .attach(new ProcedureLimitFilter(WORKLOAD_XACT_LIMIT));

            ((Workload) workload).load(file, catalog_db, filter);

        }

       

        this.catalog_proc = this.getProcedure(TARGET_PROCEDURE);

       

        if (isFirstSetup()) {

                    .include(TARGET_PROCEDURE.getSimpleName())

                    .attach(new NoAbortFilter())

                    .attach(new ProcParameterValueFilter().include(1, new Integer(5))) // D_ID

                    .attach(new ProcParameterArraySizeFilter(CatalogUtil.getArrayProcParameters(catalog_proc).get(0), 10, ExpressionType.COMPARE_EQUAL))

                    .attach(new BasePartitionTxnFilter(p_estimator, BASE_PARTITION))

            //  (2) Only include traces with 10 orderline items

            //  (3) Only include traces that execute on the BASE_PARTITION

            //  (4) Limit the total number of traces to WORKLOAD_XACT_LIMIT

            List<ProcParameter> array_params = CatalogUtil.getArrayProcParameters(this.catalog_proc);

                  .include(TARGET_PROCEDURE.getSimpleName())

                  .attach(new NoAbortFilter())

                  .attach(new ProcParameterArraySizeFilter(array_params.get(0), 10, ExpressionType.COMPARE_EQUAL))

                  .attach(new BasePartitionTxnFilter(p_estimator, BASE_PARTITION))

                  .attach(new ProcedureLimitFilter(WORKLOAD_XACT_LIMIT));

            //  (2) Only include traces with 10 orderline items

            //  (3) Only include traces that execute on the BASE_PARTITION

            //  (4) Limit the total number of traces to WORKLOAD_XACT_LIMIT

            List<ProcParameter> array_params = CatalogUtil.getArrayProcParameters(this.catalog_proc);

                  .include(TARGET_PROCEDURE.getSimpleName())

                  .attach(new NoAbortFilter())

                  .attach(new MultiPartitionTxnFilter(p_estimator, false))

                  .attach(new ProcParameterArraySizeFilter(array_params.get(0), 10, ExpressionType.COMPARE_EQUAL))

                  .attach(new ProcedureLimitFilter(WORKLOAD_XACT_LIMIT));

            // reset after each round

            VerticalPartitionColumn vp_col = null;

            // Get our workload filter for this level of the traversal

            // Descendant tables used for memory calculations

            // It's ok for it to be empty. That means we're searching against

            // all of tables

            Set<Table> current_previousTables = this.previous_tables[idx];

            // (1) Filter by procedure name

            // (2) Filter to only include multi-partition txns

            // (3) Another limit to stop after allowing ### txns

            // Where is your god now???

                    .include(TARGET_PROCEDURE.getSimpleName())

                    .attach(new BasePartitionTxnFilter(p_estimator, BASE_PARTITION))

                    .attach(new MultiPartitionTxnFilter(p_estimator, false))

                    .attach(new ProcedureLimitFilter(WORKLOAD_XACT_LIMIT));

            workload.load(file, catalogContext.database, filter);

            Procedure procs[] = { this.origProc, this.blockingProc, this.nonblockingProc };

            Workload workloads[] = new Workload[procs.length];

           

            // LOAD SAMPLE WORKLOAD

                    .include(this.origProc.getName())

                    .attach(new NoAbortFilter())

                    .attach(new ProcedureLimitFilter(WORKLOAD_XACT_LIMIT));

            File workloadFile = this.getWorkloadFile(ProjectType.SMALLBANK);

            workloads[0] = new Workload(catalogContext.catalog).load(workloadFile, catalogContext.database, filter);

            // (2) Filter on partitions that start on our BASE_PARTITION

            // (3) Filter to only include multi-partition txns

            // (4) Another limit to stop after allowing ### txns

            // Where is your god now???

                    .include(TARGET_PROCEDURE.getSimpleName())

                    .attach(new ProcParameterValueFilter().include(1, new Integer(5))) // D_ID

                    // .attach(new ProcParameterArraySizeFilter(CatalogUtil.getArrayProcParameters(catalog_proc).get(0), 10, ExpressionType.COMPARE_EQUAL))

                    .attach(new BasePartitionTxnFilter(p_estimator, BASE_PARTITION))

                    .attach(new MultiPartitionTxnFilter(p_estimator, false))

                    .attach(new ProcedureLimitFilter(WORKLOAD_XACT_LIMIT));

            workload.load(file, catalogContext.database, filter);

           

            // Make a copy that doesn't have the first TransactionTrace

                private boolean first = true;

                @Override

                protected FilterResult filter(AbstractTraceElement<? extends CatalogType> element) {

                    if (element instanceof TransactionTrace && first) {

                        this.first = false;

       

        if (workload == null) {

            File file = this.getWorkloadFile(ProjectType.TPCC);

            workload = new Workload(catalog);

                                         .attach(new ProcedureLimitFilter(WORKLOAD_XACT_LIMIT));

            workload.load(file, catalog_db, filter);

        }

       

        this.catalog_proc = this.getProcedure(TARGET_PROCEDURE);