//------------------------------------------------------------------------------
// Perform testcases for a 1 column table, a 2 column table, etc, up to
// a table having "maxCols" columns.
//------------------------------------------------------------------------------
void testSizes()
{
// Prompt for schema.
cout << "Enter Schema or Enter for " << schema << ": ";
string tmpSchema;
getline(cin, tmpSchema);
if(tmpSchema.length() > 0)
{
schema = tmpSchema;
}
// Prompt for table.
cout << "Enter Table or Enter for " << colstable << ": ";
string tmpTable;
getline(cin, tmpTable);
if(tmpTable.length() > 0)
{
colstable = tmpTable;
}
timer.start("Total");
int maxCols = 9;
cout << endl;
for(int i = 7; i <= maxCols; i++) {
cout << endl << "Running test " << i << " of " << maxCols << endl;
stringstream ss;
ss << "Delivery test for " << dataSize << " rows and " << i << " columns";
timer.start(ss.str());
deliverTest(i);
timer.stop(ss.str());
}
timer.stop("Total");
timer.finish();
}
//--------------------------------------------------------------------------
// ZDL benchmark functions
//--------------------------------------------------------------------------
void ZDL_bench_1set_seq()
{
typedef ElementType Element;
uint i;
uint numOfProducers = NUM_PRODUCERS;
uint numOfConsumers = NUM_CONSUMERS;
ZDL<Element> zdl(numOfConsumers, fRm);
zdl.setMultipleProducers(true);
zdl.setElementMode(1); // RID_VALUE
pthread_t producer[numOfProducers];
pthread_t consumer[numOfConsumers];
ThreadParms producerThreadParms[NUM_PRODUCERS];
ThreadParms consumerThreadParms[NUM_CONSUMERS];
struct timespec ts1, ts2, diff;
timer.start("zdl-produce_1set_seq");
clock_gettime(CLOCK_REALTIME, &ts1);
for (i = 0; i < numOfProducers; i++)
{
producerThreadParms[i].zdl = &zdl;
producerThreadParms[i].threadNumber = i;
producerThreadParms[i].count = ::count1Set;
pthread_create(&producer[i], NULL,
ZDL_producer_1set_seq<Element>, &producerThreadParms[i]);
}
for (i = 0; i < numOfProducers; i++)
pthread_join(producer[i], NULL);
zdl.endOfInput();
timer.stop("zdl-produce_1set_seq");
timer.start("zdl-consume_1set_seq");
for (i = 0; i < numOfConsumers; i++)
{
consumerThreadParms[i].zdl = &zdl;
consumerThreadParms[i].threadNumber = i;
consumerThreadParms[i].count = 0;
pthread_create(&consumer[i], NULL,
ZDL_consumer<Element>, &consumerThreadParms[i]);
}
for (i = 0; i < numOfConsumers; i++)
pthread_join(consumer[i], NULL);
clock_gettime(CLOCK_REALTIME, &ts2);
timer.stop("zdl-consume_1set_seq");
timer.finish();
timespec_sub(ts1, ts2, diff);
cout << "# of Producers: " << numOfProducers << endl;
cout << "# of Consumers: " << numOfConsumers << endl;
cout << "ZDL_bench_1set_seq: producer & consumer passed " <<
zdl.totalSize() << " elements in " << diff.tv_sec << "s " <<
diff.tv_nsec << "ns" << endl;
ZDL_printFileStats<Element>(&zdl);
validateResults(::count1Set*NUM_PRODUCERS);
}
//--------------------------------------------------------------------------
// test the saving and loading of a zdl file
//--------------------------------------------------------------------------
void load_save(){
typedef ElementType Element;
vector <Element> v;
for (uint i = 0; i < ::count1Set*8; i++)
v.push_back(Element(i,i));
vector<Element> v1;
vector<Element> v2;
vector<Element> v3;
// save
ofstream f1;
ifstream f;
string filename = "zdl.txt";
uint64_t ctn = v.size();
f1.open(filename.c_str(), std::ios::binary);
f1.write((char *) &ctn, sizeof(ctn));
f1.write((char *) (v.begin().operator->()), sizeof(Element) * ctn);
f.close();
// load
v1.push_back(Element(3,4));
f.open(filename.c_str(), std::ios::binary);
timer.start("read");
v1.resize(v1.size()+::count1Set*8);
f.read((char *) ((v1.begin()+1).operator->()), ctn * sizeof(Element));
cout << v1.size() << endl;
timer.stop("read");
cout << "E1: " << v1[0].first << endl;
f.close();
f.open(filename.c_str(), std::ios::binary);
timer.start("assign");
v2.assign(std::istream_iterator<Element>(f),
std::istream_iterator<Element>());
cout << v2.size() << endl;
timer.stop("assign");
f.close();
f.open(filename.c_str(), std::ios::binary);
timer.start("insert");
v3.insert(v3.end(), std::istream_iterator<Element>(f),
std::istream_iterator<Element>());
cout << v3.size() << endl;
timer.stop("insert");
f.close();
timer.finish();
}
void SWSDL_bench_mulSet_seq()
{
typedef ElementType Element;
id_sw = 0;
uint i;
uint numOfProducers = NUM_PRODUCERS;
uint numOfConsumers = NUM_CONSUMERS;
SWSDL<Element> sw(numOfConsumers, fRm);
sw.setMultipleProducers(true);
pthread_t producer[numOfProducers];
pthread_t consumer[numOfConsumers];
struct timespec ts1, ts2, diff;
timer.start("swsdl-produce");
clock_gettime(CLOCK_REALTIME, &ts1);
for (i = 0; i < numOfProducers; i++)
pthread_create(&producer[i], NULL,
SWSDL_producer_mulSet_seq<Element>, &sw);
for (i = 0; i < numOfProducers; i++)
pthread_join(producer[i], NULL);
timer.stop("swsdl-produce");
timer.start("swsdl-endofinput");
sw.endOfInput();
timer.stop("swsdl-endofinput");
//timer.stop("swsdl-produce");
timer.start("swsdl-consume");
for (i = 0; i < numOfConsumers; i++)
pthread_create(&consumer[i], NULL,
SWSDL_consumer<Element>, &sw);
for (i = 0; i < numOfConsumers; i++)
pthread_join(consumer[i], NULL);
clock_gettime(CLOCK_REALTIME, &ts2);
timer.stop("swsdl-consume");
timer.finish();
timespec_sub(ts1, ts2, diff);
cout << "# of Producers: " << numOfProducers << endl;
cout << "# of Consumers: " << numOfConsumers << endl;
cout << "SWSDL_bench_mulSet_seq: producer & consumer passed " <<
sw.totalSize() << " elements in " << diff.tv_sec << "s " <<
diff.tv_nsec << "ns" << endl;
}
//--------------------------------------------------------------------------
// test the reading of zdl configuration parameters
//--------------------------------------------------------------------------
void configure()
{
config::Config *config = config::Config::makeConfig();
std::string strVal;
strVal = config->getConfig("ZDL", "MaxMemConsumption");
uint64_t maxMemConsumption;
timer.start("configure");
for (int i = 0; i < 20; i++){
if (strVal.size() > 0){
maxMemConsumption = config::Config::uFromText(strVal);
if ((maxMemConsumption - 1) & maxMemConsumption)
throw std::runtime_error("ZDL: maxMemConsumption "
"should be a power of 2.");
}
else
maxMemConsumption = 1000000;
}
timer.stop("configure");
timer.finish();
}
//------------------------------------------------------------------------------
// Main entry point
//------------------------------------------------------------------------------
int main( int argc, char **argv)
{
if (argc > 1)
columns = atoi(argv[1]); // override default number of rows
else
columns = 10;
while (columns > 0) {
// testSizes();
nextBandBenchmark();
queuedBSBenchmark(10);
queuedBSBenchmark(9);
queuedBSBenchmark(8);
queuedBSBenchmark(5);
queuedBSBenchmark(4);
queuedBSBenchmark(1);
timer.finish();
columns--;
}
return 0;
}
void ZDL_bench_mulSet_seq_ridonly(char* testDesc, bool compress,
uint32_t size1st)
{
typedef RIDElementType Element;
uint32_t size2nd = 0;
string produceTag ("zdl-produce_ridonly");
string eofInputTag("zdl-endofinput_ridonly");
string consumeTag ("zdl-consume_ridonly");
produceTag += testDesc;
eofInputTag += testDesc;
consumeTag += testDesc;
uint i;
uint numOfProducers = NUM_PRODUCERS;
uint numOfConsumers = NUM_CONSUMERS;
ZDL<Element> zdl(numOfConsumers, fRm);
zdl.setMultipleProducers(true);
if ( compress )
zdl.setDiskElemSize ( size1st, size2nd );
pthread_t producer[numOfProducers];
pthread_t consumer[numOfConsumers];
ThreadParms producerThreadParms[NUM_PRODUCERS];
ThreadParms consumerThreadParms[NUM_CONSUMERS];
struct timespec ts1, ts2, diff;
timer.start(produceTag);
clock_gettime(CLOCK_REALTIME, &ts1);
for (i = 0; i < numOfProducers; i++)
{
producerThreadParms[i].zdl = &zdl;
producerThreadParms[i].threadNumber = i;
producerThreadParms[i].count = ::countMulSet;
pthread_create(&producer[i], NULL,
ZDL_producer_mulSet_seq_ridonly<Element>,
&producerThreadParms[i]);
}
for (i = 0; i < numOfConsumers; i++)
{
consumerThreadParms[i].zdl = &zdl;
consumerThreadParms[i].threadNumber = i;
consumerThreadParms[i].count = 0;
pthread_create(&consumer[i], NULL,
ZDL_consumer<Element>, &consumerThreadParms[i]);
}
for (i = 0; i < numOfProducers; i++)
pthread_join(producer[i], NULL);
timer.stop(produceTag);
timer.start(eofInputTag);
zdl.endOfInput();
timer.stop(eofInputTag);
timer.start(consumeTag);
for (i = 0; i < numOfConsumers; i++)
pthread_join(consumer[i], NULL);
clock_gettime(CLOCK_REALTIME, &ts2);
timer.stop(consumeTag);
timer.finish();
timespec_sub(ts1, ts2, diff);
cout << "compress state: " << (compress?"on":"off") << endl;
if (compress)
cout << "size 1st/2nd: " << size1st << "/" << size2nd << endl;
cout << "# of Producers: " << numOfProducers << endl;
cout << "# of Consumers: " << numOfConsumers << endl;
cout << "ZDL_bench_mulSet_seq_ridonly_" << testDesc <<
": producer & consumer passed " <<
zdl.totalSize() << " elements in " << diff.tv_sec << "s " <<
diff.tv_nsec << "ns" << endl;
ZDL_printFileStats<Element>(&zdl);
validateResults(::countMulSet*NUM_PRODUCERS);
}