TestMappingCalculator.java

package edu.brown.mappings;

import java.io.File;
import java.util.*;

import org.voltdb.VoltProcedure;
import org.voltdb.benchmark.tpcc.procedures.neworder;
import org.voltdb.catalog.*;

import edu.brown.BaseTestCase;
import edu.brown.mappings.AbstractMapping;
import edu.brown.mappings.ParameterMapping;
import edu.brown.mappings.MappingCalculator;
import edu.brown.mappings.ParameterMappingsSet;
import edu.brown.mappings.MappingCalculator.*;
import edu.brown.utils.CollectionUtil;
import edu.brown.utils.ProjectType;
import edu.brown.workload.*;
import edu.brown.workload.filters.Filter;
import edu.brown.workload.filters.ProcParameterValueFilter;
import edu.brown.workload.filters.ProcedureLimitFilter;
import edu.brown.workload.filters.ProcedureNameFilter;

public class TestMappingCalculator extends BaseTestCase {
    private static final int WORKLOAD_XACT_LIMIT = 1000;
    private static final Class<? extends VoltProcedure> TARGET_PROCEDURE = neworder.class;
    
    private static Workload workload;
    private Random rand = new Random(0);
    private MappingCalculator pc;
    private Procedure catalog_proc;
    
    @Override
    protected void setUp() throws Exception {
        super.setUp(ProjectType.TPCC);

        if (workload == null) {
            File file = this.getWorkloadFile(ProjectType.TPCC);
            workload = new Workload(catalog);
            Filter filter = new ProcedureNameFilter(false)
                    .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);
        }
        assert(workload.getTransactionCount() > 0);
        
        // Setup
        this.catalog_proc = this.getProcedure(TARGET_PROCEDURE);
        this.pc = new MappingCalculator(catalog_db);
    }
    
    /**
     * testQueryInstance
     */
    public void testQueryInstance() {
        ProcedureMappings procc = this.pc.getProcedureCorrelations(this.catalog_proc);
        procc.start();
        for (Statement catalog_stmt : this.catalog_proc.getStatements()) {
            Set<QueryInstance> previous = new HashSet<QueryInstance>();
            for (int i = 0; i < 2; i++) {
                QueryInstance query_instance = procc.getQueryInstance(catalog_stmt);
                assertNotNull(query_instance);
                assertEquals(i, query_instance.getSecond().intValue());
                assertFalse(previous.contains(query_instance));
                previous.add(query_instance);
            } // FOR
        } // FOR
        procc.finish();
    }
    
    /**
     * testProcParameterCorrelation
     */
    public void testProcParameterCorrelation() {
        ProcedureMappings procc = this.pc.getProcedureCorrelations(this.catalog_proc);
        procc.start();
        
        Statement catalog_stmt = CollectionUtil.first(this.catalog_proc.getStatements());
        assertNotNull(catalog_stmt);

        QueryInstance query_instance = procc.getQueryInstance(catalog_stmt);
        assertNotNull(query_instance);
        assertEquals(0, query_instance.getSecond().intValue());
        for (StmtParameter catalog_stmt_param : catalog_stmt.getParameters()) {
            Set<AbstractMapping> previous = new HashSet<AbstractMapping>();
            
            for (ProcParameter catalog_proc_param : this.catalog_proc.getParameters()) {
                ProcParameterCorrelation ppc = query_instance.getProcParameterCorrelation(catalog_stmt_param, catalog_proc_param);
                assertNotNull(ppc);
                assertEquals(catalog_proc_param.getIsarray(), ppc.getIsArray());
                assertEquals(catalog_proc_param, ppc.getProcParameter());
                
                int cnt = (ppc.getIsArray() ? rand.nextInt(10) : 1);
                for (int i = 0; i < cnt; i++) {
                    AbstractMapping correlation = ppc.getAbstractCorrelation(i);
                    assertFalse(previous.contains(correlation));
                    previous.add(correlation);
                } // FOR
            } // FOR
        } // FOR
        procc.finish();
    }
    
    /**
     * testProcessTransaction
     */
    public void testProcessTransaction() throws Exception {
        int ctr = 0;
        for (TransactionTrace xact_trace : workload) {
            assertNotNull(xact_trace);
            this.pc.processTransaction(xact_trace);
            if (ctr++ >= 100) break;
        } // FOR
        this.pc.calculate();
        
        ProcedureMappings procc = this.pc.getProcedureCorrelations(this.catalog_proc);
        assertNotNull(procc);
//         System.err.println(xact_trace.debug(catalog_db));
        
        Statement catalog_stmt = this.catalog_proc.getStatements().get("getStockInfo");
        assertNotNull(catalog_stmt);
        
        double threshold = 1.0d;
        ParameterMappingsSet pc = procc.getCorrelations(threshold);
        assertNotNull(pc);
//        System.err.println(pc.debug());
        SortedMap<Integer, SortedMap<StmtParameter, SortedSet<ParameterMapping>>> stmt_correlations = pc.get(catalog_stmt);
        assertNotNull(stmt_correlations);
        assertFalse(stmt_correlations.isEmpty());
//        assertEquals(1, stmt_correlations.size());
        SortedMap<StmtParameter, SortedSet<ParameterMapping>> param_correlations = stmt_correlations.get(0);
        assertEquals(catalog_stmt.getParameters().size(), param_correlations.size());
        
//        System.err.println(procc.debug(catalog_stmt));
//        System.err.print(CorrelationCalculator.DEFAULT_DOUBLE_LINE);
//        for (StmtParameter catalog_stmt_param : param_correlations.keySet()) {
//            System.err.println(catalog_stmt_param + ": " + param_correlations.get(catalog_stmt_param));
//        }
//        System.err.print(CorrelationCalculator.DEFAULT_DOUBLE_LINE);
//        System.err.println(pc.debug(catalog_stmt));
//        System.err.print(CorrelationCalculator.DEFAULT_DOUBLE_LINE);
//        System.err.println("FULL DUMP:");
//        for (Correlation c : pc) {
//            if (c.getStatement().equals(catalog_stmt)) System.err.println("   " + c);
//        }
//        System.err.print(CorrelationCalculator.DEFAULT_DOUBLE_LINE);
        
        ProcParameter expected_param[] = new ProcParameter[] {
                this.catalog_proc.getParameters().get(4),
                this.catalog_proc.getParameters().get(5),
        };
        int expected_index[] = { 0, 14 }; // ???
        
        for (int i = 0, cnt = catalog_stmt.getParameters().size(); i < cnt; i++) {
            StmtParameter catalog_param = catalog_stmt.getParameters().get(i);
            assertNotNull(catalog_param);
            ParameterMapping c = CollectionUtil.first(param_correlations.get(catalog_param));
            assertNotNull(c);
            
            assert(c.getCoefficient() >= threshold);
            assertEquals("[" + i + "]", expected_param[i], c.getProcParameter());
            assertEquals("[" + i + "]", expected_index[i], c.getProcParameterIndex());
        } // FOR
    }
    
}