package edu.brown.designer;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import org.voltdb.CatalogContext;
import org.voltdb.catalog.Database;
import edu.brown.catalog.DependencyUtil;
import edu.brown.costmodel.AbstractCostModel;
import edu.brown.costmodel.SingleSitedCostModel;
import edu.brown.designer.generators.DependencyGraphGenerator;
import edu.brown.designer.indexselectors.AbstractIndexSelector;
import edu.brown.designer.mappers.AbstractMapper;
import edu.brown.designer.partitioners.AbstractPartitioner;
import edu.brown.graphs.AbstractDirectedGraph;
import edu.brown.hashing.DefaultHasher;
import edu.brown.mappings.ParameterMappingsSet;
import edu.brown.statistics.WorkloadStatistics;
import edu.brown.utils.ArgumentsParser;
import edu.brown.workload.Workload;
/**
* Container object for the various information that a designer will need to use
* to create a new physical database design.
*
* @author pavlo
*/
public class DesignerInfo {
/**
* Cache of DependencyGraphs for Database catalog objects
*/
private final static Map<Database, DependencyGraph> DGRAPH_CACHE = new HashMap<Database, DependencyGraph>();
/**
* Keep this around in case we need it later on
*/
private final ArgumentsParser args;
/**
* The base database catalog object that the designer is creating a physical
* plan for
*/
public final CatalogContext catalogContext;
/**
* The DependencyGraph of the schema
*/
public final DependencyGraph dgraph;
/**
* The sample workload trace used as the basis of the physical design
*/
public Workload workload;
/**
* WorkloadStatistics
*/
public WorkloadStatistics stats;
/**
* Dependencies
*/
public final DependencyUtil dependencies;
/**
* ProcParameter Correlations
*/
private ParameterMappingsSet mappings;
private File correlations_file;
/**
* Designer Components Defaults defined in ArgumentParser
*/
public Class<? extends AbstractPartitioner> partitioner_class;
public Class<? extends AbstractMapper> mapper_class;
public Class<? extends AbstractIndexSelector> indexer_class;
/**
* Cost Model Components
*/
public Class<? extends AbstractCostModel> costmodel_class = SingleSitedCostModel.class;
private AbstractCostModel costmodel;
private MemoryEstimator m_estimator;
/**
* Number of concurrent threads to use
*/
private int num_threads;
/**
* The number of time intervals to use when dividing up the workload
* information
*/
private int num_intervals;
/**
* Number of partitions
*/
private final int num_partitions;
/**
* Where the designer can write out checkpoint information
*/
private File checkpoint;
/**
* Copy Constructor
*
* @param src
*/
public DesignerInfo(DesignerInfo src) {
this.args = src.args;
this.catalogContext = src.catalogContext;
this.workload = src.workload;
this.stats = src.stats;
this.partitioner_class = src.partitioner_class;
this.mapper_class = src.mapper_class;
this.indexer_class = src.indexer_class;
this.num_threads = src.num_threads;
this.num_intervals = src.num_intervals;
this.num_partitions = src.num_partitions;
this.dependencies = src.dependencies;
this.costmodel_class = src.costmodel_class;
this.costmodel = src.costmodel;
this.checkpoint = src.checkpoint;
this.m_estimator = src.m_estimator;
this.mappings = src.mappings;
this.correlations_file = src.correlations_file;
this.dgraph = src.dgraph;
}
/**
* @param catalogContext
* @param workload
* @param stats
* @param hints
*/
public DesignerInfo(ArgumentsParser args) {
this.args = args;
this.catalogContext = args.catalogContext;
this.workload = args.workload;
this.stats = args.stats;
this.partitioner_class = args.partitioner_class;
this.mapper_class = args.mapper_class;
this.indexer_class = args.indexer_class;
this.num_threads = args.max_concurrent;
this.num_intervals = args.num_intervals;
this.num_partitions = this.catalogContext.numberOfPartitions;
this.dependencies = DependencyUtil.singleton(this.catalogContext.database);
this.costmodel_class = args.costmodel_class;
this.costmodel = args.costmodel;
this.checkpoint = args.designer_checkpoint;
// Memory Estimator
this.m_estimator = new MemoryEstimator(this.stats, new DefaultHasher(this.catalogContext, this.num_partitions));
// Correlations (smoke 'em if you got 'em)
if (args.param_mappings != null) {
this.mappings = args.param_mappings;
this.correlations_file = args.getFileParam(ArgumentsParser.PARAM_MAPPINGS);
} else if (this.catalogContext.paramMappings != null) {
this.mappings = this.catalogContext.paramMappings;
}
if (!DesignerInfo.DGRAPH_CACHE.containsKey(this.catalogContext.database)) {
this.dgraph = new DependencyGraph(this.catalogContext.database);
try {
new DependencyGraphGenerator(this).generate(this.dgraph);
} catch (Exception ex) {
ex.printStackTrace();
System.exit(1);
}
DesignerInfo.DGRAPH_CACHE.put(this.catalogContext.database, this.dgraph);
} else {
this.dgraph = DesignerInfo.DGRAPH_CACHE.get(this.catalogContext.database);
}
}
/**
* Constructor
*
* @param args
*/
public DesignerInfo(final CatalogContext _catalogContext, final Workload _workload, final WorkloadStatistics _stats) {
this(new ArgumentsParser() {
{
this.catalogContext = _catalogContext;
this.catalog_db = _catalogContext.database;
this.workload = _workload;
this.stats = _stats;
}
});
}
/**
* Constructor
*
* @param catalogContext
* @param workload
*/
public DesignerInfo(CatalogContext catalogContext, Workload workload) {
this(catalogContext, workload, new WorkloadStatistics(catalogContext.database));
}
public Workload getWorkload() {
return this.workload;
}
public void setWorkload(Workload workload) {
this.workload = workload;
}
/** Parameter Mappings **/
public void setMappings(ParameterMappingsSet mappings) {
this.mappings = mappings;
}
public ParameterMappingsSet getMappings() {
return mappings;
}
public void setMappingsFile(File file) {
correlations_file = file;
}
public File getMappingsFile() {
return correlations_file;
}
/** Workload Statistics **/
public void setStats(WorkloadStatistics stats) {
this.stats = stats;
this.m_estimator = new MemoryEstimator(this.stats, this.m_estimator.getHasher());
}
public WorkloadStatistics getStats() {
return this.stats;
}
/** DependencyUtil **/
public DependencyUtil getDependencies() {
return this.dependencies;
}
public AbstractDirectedGraph<DesignerVertex, DesignerEdge> getDependencyGraph() {
return this.dgraph;
}
public ArgumentsParser getArgs() {
return this.args;
}
public Class<? extends AbstractPartitioner> getPartitionerClass() {
return partitioner_class;
}
public void setPartitionerClass(Class<? extends AbstractPartitioner> partitionerClass) {
partitioner_class = partitionerClass;
}
public Class<? extends AbstractMapper> getMapperClass() {
return mapper_class;
}
public void setMapperClass(Class<? extends AbstractMapper> mapperClass) {
mapper_class = mapperClass;
}
public Class<? extends AbstractIndexSelector> getIndexerClass() {
return indexer_class;
}
public void setIndexerClass(Class<? extends AbstractIndexSelector> indexerClass) {
indexer_class = indexerClass;
}
public Class<? extends AbstractCostModel> getCostModelClass() {
return costmodel_class;
}
public void setCostModelClass(Class<? extends AbstractCostModel> costModelClass) {
costmodel_class = costModelClass;
}
public AbstractCostModel getCostModel() {
return costmodel;
}
public void setCostModel(AbstractCostModel costmodel) {
this.costmodel = costmodel;
}
public MemoryEstimator getMemoryEstimator() {
return (this.m_estimator);
}
public int getNumThreads() {
return this.num_threads;
}
public void setNumThreads(int num_threads) {
this.num_threads = num_threads;
}
public int getNumIntervals() {
return this.num_intervals;
}
public void setNumIntervals(int numIntervals) {
this.num_intervals = numIntervals;
}
public int getNumPartitions() {
return num_partitions;
}
public void setCheckpointFile(File checkpoint) {
this.checkpoint = checkpoint;
}
public File getCheckpointFile() {
return this.checkpoint;
}
}