//------------------------------------------------------------------------------
// 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();
}
void
EventDeliveryManager::gather_events( bool done )
{
// IMPORTANT: Ensure that gather_events(..) is called from a single thread and
// NOT from a parallel OpenMP region!!!
// Stop watch for time measurements within this function
static Stopwatch stw_local;
stw_local.reset();
stw_local.start();
collocate_buffers_( done );
stw_local.stop();
time_collocate_ += stw_local.elapsed();
stw_local.reset();
stw_local.start();
if ( off_grid_spiking_ )
{
kernel().mpi_manager.communicate(
local_offgrid_spikes_, global_offgrid_spikes_, displacements_ );
}
else
{
kernel().mpi_manager.communicate(
local_grid_spikes_, global_grid_spikes_, displacements_ );
}
stw_local.stop();
time_communicate_ += stw_local.elapsed();
}
ADD_TEST(StopWatchTest, TestAll) {
Stopwatch sw;
sw.start();
this_thread::sleep_for(chrono::milliseconds(200));
sw.stop();
Int64 d = sw.elapsed();
CHECK(d > 180000);
CHECK(d < 300000);
sw.start();
this_thread::sleep_for(chrono::milliseconds(100));
sw.stop();
d = sw.elapsed();
CHECK(d > 280000);
CHECK(d < 400000);
this_thread::sleep_for(chrono::milliseconds(100));
sw.stop();
d = sw.elapsed();
CHECK(d > 380000);
CHECK(d < 500000);
sw.restart();
sw.start();
this_thread::sleep_for(chrono::milliseconds(200));
sw.stop();
d = sw.elapsed();
CHECK(d > 180000);
CHECK(d < 300000);
}
//--------------------------------------------------------------------------
// 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);
}
int main(int, char **)
try
{
std::cout << std::fixed << std::setprecision(2);
size_t n = 100000000;
Stopwatch stopwatch;
{
DB::WriteBufferFromFile buf("test_zlib_buffers.gz", DBMS_DEFAULT_BUFFER_SIZE, O_WRONLY | O_CREAT | O_TRUNC);
DB::ZlibDeflatingWriteBuffer deflating_buf(buf, DB::CompressionMethod::Gzip, /* compression_level = */ 3);
stopwatch.restart();
for (size_t i = 0; i < n; ++i)
{
DB::writeIntText(i, deflating_buf);
DB::writeChar('\t', deflating_buf);
}
deflating_buf.finish();
stopwatch.stop();
std::cout << "Writing done. Elapsed: " << stopwatch.elapsedSeconds() << " s."
<< ", " << (deflating_buf.count() / stopwatch.elapsedSeconds() / 1000000) << " MB/s"
<< std::endl;
}
{
DB::ReadBufferFromFile buf("test_zlib_buffers.gz");
DB::ZlibInflatingReadBuffer inflating_buf(buf, DB::CompressionMethod::Gzip);
stopwatch.restart();
for (size_t i = 0; i < n; ++i)
{
size_t x;
DB::readIntText(x, inflating_buf);
inflating_buf.ignore();
if (x != i)
throw DB::Exception("Failed!, read: " + std::to_string(x) + ", expected: " + std::to_string(i), 0);
}
stopwatch.stop();
std::cout << "Reading done. Elapsed: " << stopwatch.elapsedSeconds() << " s."
<< ", " << (inflating_buf.count() / stopwatch.elapsedSeconds() / 1000000) << " MB/s"
<< std::endl;
}
return 0;
}
catch (const DB::Exception & e)
{
std::cerr << e.what() << ", " << e.displayText() << std::endl;
return 1;
}
static void NO_INLINE execute(const Source & data, size_t num_threads,
Creator && creator, Updater && updater, Merger && merger,
ThreadPool & pool)
{
std::vector<std::unique_ptr<Map>> intermediate_results;
Stopwatch watch;
Aggregate::execute(data, num_threads, intermediate_results, std::forward<Creator>(creator), std::forward<Updater>(updater), pool);
size_t num_maps = intermediate_results.size();
watch.stop();
double time_aggregated = watch.elapsedSeconds();
std::cerr
<< "Aggregated in " << time_aggregated
<< " (" << data.size() / time_aggregated << " elem/sec.)"
<< std::endl;
size_t size_before_merge = 0;
std::cerr << "Sizes: ";
for (size_t i = 0; i < num_threads; ++i)
{
std::cerr << (i == 0 ? "" : ", ") << intermediate_results[i]->size();
size_before_merge += intermediate_results[i]->size();
}
std::cerr << std::endl;
watch.restart();
std::vector<Map*> intermediate_results_ptrs(num_maps);
for (size_t i = 0; i < num_maps; ++i)
intermediate_results_ptrs[i] = intermediate_results[i].get();
Map * result_map;
Merge::execute(intermediate_results_ptrs.data(), num_maps, result_map, std::forward<Merger>(merger), pool);
watch.stop();
double time_merged = watch.elapsedSeconds();
std::cerr
<< "Merged in " << time_merged
<< " (" << size_before_merge / time_merged << " elem/sec.)"
<< std::endl;
double time_total = time_aggregated + time_merged;
std::cerr
<< "Total in " << time_total
<< " (" << data.size() / time_total << " elem/sec.)"
<< std::endl;
std::cerr << "Size: " << result_map->size() << std::endl << std::endl;
}
//--------------------------------------------------------------------------
// 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();
}
string OriCommand::cmd_merge(strstream &str)
{
#if defined(DEBUG) || defined(ORI_PERF)
Stopwatch sw = Stopwatch();
sw.start();
#endif /* DEBUG */
FUSE_PLOG("Command: merge");
string error;
ObjectHash hash;
strwstream resp;
// Parse Command
str.readHash(hash);
RWKey::sp lock = priv->nsLock.writeLock();
error = priv->merge(hash);
lock.reset();
if (error != "") {
resp.writeUInt8(0);
resp.writePStr(error);
} else {
resp.writeUInt8(1);
}
#if defined(DEBUG) || defined(ORI_PERF)
sw.stop();
FUSE_PLOG("merge with: %s", hash.hex().c_str());
FUSE_PLOG("merge elapsed %lluus", sw.getElapsedTime());
#endif /* DEBUG */
return resp.str();
}
void RunOCLMatMulForKernel(
float * arg_A, size_t arg_hst_ptrA_dim1, size_t arg_hst_ptrA_dim2,
float * arg_C, size_t arg_hst_ptrC_dim1, size_t arg_hst_ptrC_dim2,
float * arg_B, size_t arg_hst_ptrB_dim1, size_t arg_hst_ptrB_dim2,
unsigned arg_wB, unsigned arg_wA, unsigned arg_hA
)
{
if (isFirstTime)
{
hst_ptrA = arg_A;
hst_ptrA_dim1 = arg_hst_ptrA_dim1;
hst_ptrA_dim2 = arg_hst_ptrA_dim2;
hst_ptrC = arg_C;
hst_ptrC_dim1 = arg_hst_ptrC_dim1;
hst_ptrC_dim2 = arg_hst_ptrC_dim2;
hst_ptrB = arg_B;
hst_ptrB_dim1 = arg_hst_ptrB_dim1;
hst_ptrB_dim2 = arg_hst_ptrB_dim2;
wB = arg_wB;
wA = arg_wA;
hA = arg_hA;
StartUpGPU();
AllocateBuffers();
cout << "$Defines " << KernelDefines << endl;
compileKernel(
"MatMulFor", "MatMulFor.cl", GetKernelCode(),
false, &MatMulForKernel, KernelDefines
);
SetArgumentsMatMulFor();
}
timer.start();
ExecMatMulFor();
cout << "$Time " << timer.stop() << endl;
}
void RunOCLNBodyForKernel(
float * arg_Mas, size_t arg_hst_ptrMas_dim1, float * arg_Pos,
size_t arg_hst_ptrPos_dim1, size_t arg_hst_ptrPos_dim2, float * arg_Forces,
size_t arg_hst_ptrForces_dim1, size_t arg_hst_ptrForces_dim2, size_t arg_N
)
{
if (isFirstTime)
{
hst_ptrMas = arg_Mas;
hst_ptrMas_dim1 = arg_hst_ptrMas_dim1;
hst_ptrPos = arg_Pos;
hst_ptrPos_dim1 = arg_hst_ptrPos_dim1;
hst_ptrPos_dim2 = arg_hst_ptrPos_dim2;
hst_ptrForces = arg_Forces;
hst_ptrForces_dim1 = arg_hst_ptrForces_dim1;
hst_ptrForces_dim2 = arg_hst_ptrForces_dim2;
N = arg_N;
StartUpGPU();
AllocateBuffers();
cout << "$Defines " << KernelDefines << endl;
compileKernel(
"NBodyFor", "NBodyFor.cl", GetKernelCode(),
false, &NBodyForKernel, KernelDefines
);
SetArgumentsNBodyFor();
}
timer.start();
ExecNBodyFor();
cout << "$Time " << timer.stop() << endl;
}
void test(size_t n, const char * name, F && kernel)
{
x = 0;
Stopwatch watch;
Stopwatch watch_one;
double max_seconds = 0;
std::cerr << name << ":\n";
for (size_t i = 0; i < n; ++i)
{
watch_one.restart();
kernel();
watch_one.stop();
if (watch_one.elapsedSeconds() > max_seconds)
max_seconds = watch_one.elapsedSeconds();
}
watch.stop();
std::cerr
<< std::fixed << std::setprecision(2)
<< n << " ops in "
<< watch.elapsedSeconds() << " sec., "
<< n / watch.elapsedSeconds() << " ops/sec., "
<< "avg latency: " << watch.elapsedSeconds() / n * 1000000 << " μs, "
<< "max latency: " << max_seconds * 1000000 << " μs "
<< "(res = " << x << ")"
<< std::endl;
}
int main(int argc, char** argv)
{
verbose = getenv("PEGASUS_TEST_VERBOSE") ? true : false;
Stopwatch sw;
sw.start();
System::sleep(5);
sw.stop();
double elapsed = sw.getElapsed();
if(verbose)
{
sw.printElapsed();
}
PEGASUS_TEST_ASSERT((elapsed >= 4.5) && (elapsed <= 5.5));
cout << argv[0] << " +++++ passed all tests" << endl;
return 0;
}
void queuedBSBenchmark(int queueLength)
{
ByteStream *bs;
pthread_t threads[columns];
uint i, rowCount = 1;
JobStepAssociation inJs;
for (i = 0; i < columns; ++i) {
AnyDataListSPtr spdl1(new AnyDataList());
FIFO<UintRowGroup>* dl1 = new FIFO<UintRowGroup>(1, fifoSize);
dl1->OID(i); // lineitem first col object id
spdl1->fifoDL(dl1);
inJs.outAdd(spdl1);
pthread_create(&threads[i], 0, nextBandBenchProducer, dl1 );
cout << "started thread " << i << endl;
}
DeliveryStep ds(inJs, JobStepAssociation(), 8);
BSQueueMgr bsq(&ds, queueLength);
stringstream ss;
ss << "queuedBSBenchmark with " << columns << " columns and " << queueLength << " queue length\n";
timer.start(ss.str());
boost::thread(BSProjectThread(&bsq));
while (rowCount != 0) {
bs = bsq.getNextByteStream(rowCount);
delete bs;
}
timer.stop(ss.str());
for (i = 0; i < columns; ++i)
pthread_join(threads[i], NULL);
}
void RunOCLNBody2ForKernel(
float * arg_Mas, size_t arg_hst_ptrMas_dim1, float * arg_Forces_y,
size_t arg_hst_ptrForces_y_dim1, size_t arg_hst_ptrForces_y_dim2, float * arg_Pos,
size_t arg_hst_ptrPos_dim1, size_t arg_hst_ptrPos_dim2, float * arg_Forces_x,
size_t arg_hst_ptrForces_x_dim1, size_t arg_hst_ptrForces_x_dim2, size_t arg_N
)
{
if (isFirstTime)
{
hst_ptrMas = arg_Mas;
hst_ptrMas_dim1 = arg_hst_ptrMas_dim1;
hst_ptrForces_y = arg_Forces_y;
hst_ptrForces_y_dim1 = arg_hst_ptrForces_y_dim1;
hst_ptrForces_y_dim2 = arg_hst_ptrForces_y_dim2;
hst_ptrPos = arg_Pos;
hst_ptrPos_dim1 = arg_hst_ptrPos_dim1;
hst_ptrPos_dim2 = arg_hst_ptrPos_dim2;
hst_ptrForces_x = arg_Forces_x;
hst_ptrForces_x_dim1 = arg_hst_ptrForces_x_dim1;
hst_ptrForces_x_dim2 = arg_hst_ptrForces_x_dim2;
N = arg_N;
StartUpGPU();
AllocateBuffers();
compileKernelFromFile(
"NBody2For", "NBody2For.cl", KernelString(),
true, &NBody2ForKernel, KernelDefines
);
SetArgumentsNBody2For();
}
timer.start();
ExecNBody2For();
cout << timer.stop() << endl;
}
void walk_tree()
{
static Stopwatch timer;
timer.start();
scale_factor = sqrt(2.0*pow(((double)width/(bbmax-bbmin).max()), 2.0));
vert_ls splats = sphere_tree->recurseToDepth(recursion_depth);
splats.sort(testSize);
maxSplatSize = scale_factor * (splats.front()->size - splats.back()-> size)/2.0;
fastSplats.clear();
fastSplats.reserve(splats.size());
for (vert_it it = splats.begin(); it != splats.end(); it++)
{
fastSplats.push_back(**it);
}
splatParts.clear();
splatSizes.clear();
partitionSizes(fastSplats.begin(), fastSplats.end(), 5);
splatParts.push_back(fastSplats.end());
cout << splatSizes.size() << endl;
timer.stop();
printf("Recursed to depth %u in %f seconds\n", recursion_depth, timer.time());
printf("Displaying %lu splats, with %lu sizes\n", splats.size(), splatSizes.size() );
timer.reset();
}
Result benchmarkSingleRun(OpenANN::Environment& environment, OpenANN::Agent& agent)
{
Result result;
int maximalEpisodes = 100000;
int requiredSteps = 100000;
agent.abandoneIn(environment);
result.success = false;
Stopwatch sw;
for(int i = 1; i <= maximalEpisodes; i++)
{
environment.restart();
while(!environment.terminalState())
agent.chooseAction();
if(environment.stepsInEpisode() >= requiredSteps)
{
result.success = true;
result.episodes = i;
break;
}
}
result.time = sw.stop(Stopwatch::MILLISECOND);
return result;
}
double seissol::miniSeisSol(initializers::MemoryManager& memoryManager) {
struct GlobalData* globalData = memoryManager.getGlobalData();
initializers::LTSTree ltsTree;
initializers::LTS lts;
lts.addTo(ltsTree);
ltsTree.setNumberOfTimeClusters(1);
ltsTree.fixate();
initializers::TimeCluster& cluster = ltsTree.child(0);
cluster.child<Ghost>().setNumberOfCells(0);
cluster.child<Copy>().setNumberOfCells(0);
cluster.child<Interior>().setNumberOfCells(50000);
ltsTree.allocateVariables();
ltsTree.touchVariables();
initializers::Layer& layer = cluster.child<Interior>();
layer.setBucketSize(lts.buffersDerivatives, sizeof(real) * tensor::I::size() * layer.getNumberOfCells());
ltsTree.allocateBuckets();
fakeData(lts, layer);
localIntegration(globalData, lts, layer);
Stopwatch stopwatch;
stopwatch.start();
for (unsigned t = 0; t < 10; ++t) {
localIntegration(globalData, lts, layer);
}
return stopwatch.stop();
}
int mainImpl(int argc, char ** argv)
{
const char * file_name = 0;
int mode = MODE_READ;
size_t min_offset = 0;
size_t max_offset = 0;
size_t block_size = 0;
size_t buffers_count = 0;
size_t threads_count = 0;
size_t count = 0;
if (argc != 9)
{
std::cerr << "Usage: " << argv[0] << " file_name r|w min_offset max_offset block_size threads buffers count" << std::endl;
return 1;
}
file_name = argv[1];
if (argv[2][0] == 'w')
mode = MODE_WRITE;
min_offset = Poco::NumberParser::parseUnsigned64(argv[3]);
max_offset = Poco::NumberParser::parseUnsigned64(argv[4]);
block_size = Poco::NumberParser::parseUnsigned64(argv[5]);
threads_count = Poco::NumberParser::parseUnsigned(argv[6]);
buffers_count = Poco::NumberParser::parseUnsigned(argv[7]);
count = Poco::NumberParser::parseUnsigned(argv[8]);
int fd = open(file_name, ((mode == MODE_READ) ? O_RDONLY : O_WRONLY) | O_DIRECT);
if (-1 == fd)
throwFromErrno("Cannot open file");
using Exceptions = std::vector<std::exception_ptr>;
boost::threadpool::pool pool(threads_count);
Exceptions exceptions(threads_count);
Stopwatch watch;
for (size_t i = 0; i < threads_count; ++i)
pool.schedule(std::bind(thread, fd, mode, min_offset, max_offset, block_size, buffers_count, count, std::ref(exceptions[i])));
pool.wait();
watch.stop();
for (size_t i = 0; i < threads_count; ++i)
if (exceptions[i])
std::rethrow_exception(exceptions[i]);
if (0 != close(fd))
throwFromErrno("Cannot close file");
std::cout << std::fixed << std::setprecision(2)
<< "Done " << count << " * " << threads_count << " ops";
std::cout << " in " << watch.elapsedSeconds() << " sec."
<< ", " << count * threads_count / watch.elapsedSeconds() << " ops/sec."
<< ", " << count * threads_count * block_size / watch.elapsedSeconds() / 1000000 << " MB/sec."
<< std::endl;
return 0;
}
void RunOCLKNearestForKernel(
unsigned arg_dim, float * arg_test_patterns, size_t arg_hst_ptrtest_patterns_dim1,
size_t arg_hst_ptrtest_patterns_dim2, float * arg_dist_matrix, size_t arg_hst_ptrdist_matrix_dim1,
size_t arg_hst_ptrdist_matrix_dim2, float * arg_train_patterns, size_t arg_hst_ptrtrain_patterns_dim1,
size_t arg_hst_ptrtrain_patterns_dim2, unsigned arg_NTEST, unsigned arg_NTRAIN
)
{
if (isFirstTime)
{
dim = arg_dim;
hst_ptrtest_patterns = arg_test_patterns;
hst_ptrtest_patterns_dim1 = arg_hst_ptrtest_patterns_dim1;
hst_ptrtest_patterns_dim2 = arg_hst_ptrtest_patterns_dim2;
hst_ptrdist_matrix = arg_dist_matrix;
hst_ptrdist_matrix_dim1 = arg_hst_ptrdist_matrix_dim1;
hst_ptrdist_matrix_dim2 = arg_hst_ptrdist_matrix_dim2;
hst_ptrtrain_patterns = arg_train_patterns;
hst_ptrtrain_patterns_dim1 = arg_hst_ptrtrain_patterns_dim1;
hst_ptrtrain_patterns_dim2 = arg_hst_ptrtrain_patterns_dim2;
NTEST = arg_NTEST;
NTRAIN = arg_NTRAIN;
StartUpGPU();
AllocateBuffers();
cout << "$Defines " << KernelDefines << endl;
compileKernel(
"KNearestFor", "KNearestFor.cl", GetKernelCode(),
false, &KNearestForKernel, KernelDefines
);
SetArgumentsKNearestFor();
}
timer.start();
ExecKNearestFor();
cout << "$Time " << timer.stop() << endl;
}
void NO_INLINE bench(const std::vector<UInt16> & data, const char * name)
{
Map map;
typename Map::iterator it;
bool inserted;
Stopwatch watch;
for (size_t i = 0, size = data.size(); i < size; ++i)
{
map.emplace(data[i], it, inserted);
if (inserted)
it->getSecond() = 1;
else
++it->getSecond();
}
for (size_t i = 0, size = data.size(); i < size; ++i)
{
it = map.find(data[i]);
++it->getSecond();
}
watch.stop();
std::cerr << std::fixed << std::setprecision(2) << "HashMap (" << name << "). Size: " << map.size()
<< ", elapsed: " << watch.elapsedSeconds() << " (" << data.size() / watch.elapsedSeconds() << " elem/sec.)"
#ifdef DBMS_HASH_MAP_COUNT_COLLISIONS
<< ", collisions: " << map.getCollisions()
#endif
<< std::endl;
}
std::int64_t OneToOneSequencedBatchThroughputTest::run(Stopwatch& stopwatch)
{
m_taskScheduler->start(requiredProcessorCount());
TestTools::ScopeExitFunctor atScopeExit([this] { m_taskScheduler->stop(); });
auto signal = std::make_shared< Tests::ManualResetEvent >(false);
auto expectedCount = m_batchEventProcessor->sequence()->value() + m_iterations * m_batchSize;
m_handler->reset(signal, expectedCount);
auto processorTask = m_executor->execute([this] { m_batchEventProcessor->run(); });
stopwatch.start();
auto&& rb = *m_ringBuffer;
for (auto i = 0; i < m_iterations; ++i)
{
auto hi = rb.next(m_batchSize);
auto lo = hi - (m_batchSize - 1);
for (auto l = lo; l <= hi; ++l)
{
rb[l].value = (i);
}
rb.publish(lo, hi);
}
signal->waitOne();
stopwatch.stop();
PerfTestUtil::waitForEventProcessorSequence(expectedCount, m_batchEventProcessor);
m_batchEventProcessor->halt();
processorTask.wait_for(std::chrono::milliseconds(2000));
PerfTestUtil::failIfNot(m_expectedResult, m_handler->value(),
"Handler should have processed " + std::to_string(m_expectedResult) + " events, but was: " + std::to_string(m_handler->value()));
return m_batchSize * m_iterations;
}
void doFollyDynamic(std::vector<std::string> strvec)
{
std::cout << "folly::dynamic" << std::endl;
std::cout << "==============" << std::endl;
std::vector<std::string>::iterator it = strvec.begin();
std::vector<std::string>::iterator end = strvec.end();
Stopwatch sw;
sw.start();
for (; it != end; ++it)
{
dynamic var(*it);
int i = var.asInt();
double d = var.asDouble();
var = i;
std::string s = var.asString().c_str();
var = d;
s = var.asString().c_str();
}
sw.stop();
std::cout << "folly::dynamic: " << sw.elapsed()/1000.0 << " [ms]" << std::endl;
std::cout << "==============" << std::endl;
}
int main(int argc, char ** argv)
{
try
{
DB::ReadBufferFromFileDescriptor in(STDIN_FILENO);
Int64 n = 0;
size_t nums = 0;
Stopwatch watch;
while (!in.eof())
{
DB::readIntText(n, in);
in.ignore();
//std::cerr << "n: " << n << std::endl;
++nums;
}
watch.stop();
std::cerr << std::fixed << std::setprecision(2)
<< "Read " << nums << " numbers (" << in.count() / 1000000.0 << " MB) in " << watch.elapsedSeconds() << " sec., "
<< nums / watch.elapsedSeconds() << " num/sec. (" << in.count() / watch.elapsedSeconds() / 1000000 << " MB/s.)"
<< std::endl;
}
catch (const DB::Exception & e)
{
std::cerr << e.what() << ", " << e.displayText() << std::endl;
return 1;
}
return 0;
}
void PingPongSequencedLatencyTest::run(Stopwatch& stopwatch, const std::shared_ptr< Tests::LatencyRecorder >& latencyRecorder)
{
m_taskScheduler->start(requiredProcessorCount());
TestTools::ScopeExitFunctor atScopeExit([this] { m_taskScheduler->stop(); });
auto globalSignal = std::make_shared< Tests::CountdownEvent >(3);
auto signal = std::make_shared< Tests::ManualResetEvent >(false);
m_pinger->reset(globalSignal, signal, latencyRecorder);
m_ponger->reset(globalSignal);
auto processorTask1 = m_executor->execute([this] { m_pongProcessor->run(); });
auto processorTask2 = m_executor->execute([this] { m_pingProcessor->run(); });
globalSignal->signal();
globalSignal->wait();
stopwatch.start();
// running here
signal->waitOne();
stopwatch.stop();
m_pingProcessor->halt();
m_pongProcessor->halt();
processorTask1.wait();
processorTask2.wait();
}
void NO_INLINE bench(const std::vector<StringRef> & data, const char * name)
{
Stopwatch watch;
using Map = HashMapWithSavedHash<Key, Value, DefaultHash<Key>>;
Map map;
typename Map::iterator it;
bool inserted;
for (size_t i = 0, size = data.size(); i < size; ++i)
{
map.emplace(static_cast<const Key &>(data[i]), it, inserted);
if (inserted)
it->second = 0;
++it->second;
}
watch.stop();
std::cerr << std::fixed << std::setprecision(2)
<< "HashMap (" << name << "). Size: " << map.size()
<< ", elapsed: " << watch.elapsedSeconds()
<< " (" << data.size() / watch.elapsedSeconds() << " elem/sec.)"
#ifdef DBMS_HASH_MAP_COUNT_COLLISIONS
<< ", collisions: " << map.getCollisions()
#endif
<< std::endl;
}
void RunOCLJacobiForKernel(
float * arg_X2, size_t arg_hst_ptrX2_dim1, size_t arg_hst_ptrX2_dim2,
float * arg_X1, size_t arg_hst_ptrX1_dim1, size_t arg_hst_ptrX1_dim2,
float * arg_B, size_t arg_hst_ptrB_dim1, size_t arg_hst_ptrB_dim2,
unsigned arg_wB, unsigned arg_wA)
{
if (isFirstTime)
{
hst_ptrX2 = arg_X2;
hst_ptrX2_dim1 = arg_hst_ptrX2_dim1;
hst_ptrX2_dim2 = arg_hst_ptrX2_dim2;
hst_ptrX1 = arg_X1;
hst_ptrX1_dim1 = arg_hst_ptrX1_dim1;
hst_ptrX1_dim2 = arg_hst_ptrX1_dim2;
hst_ptrB = arg_B;
hst_ptrB_dim1 = arg_hst_ptrB_dim1;
hst_ptrB_dim2 = arg_hst_ptrB_dim2;
wB = arg_wB;
wA = arg_wA;
StartUpGPU();
AllocateBuffers();
cout << "$Defines " << KernelDefines << endl;
compileKernel(
"JacobiFor", "JacobiFor.cl", GetKernelCode(),
false, &JacobiForKernel, KernelDefines
);
SetArgumentsJacobiFor();
}
timer.start();
ExecJacobiFor();
cout << "$Time " << timer.stop() << endl;
}
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(METRICS_STOPWATCH, Short)
{
Stopwatch sw;
sw.start();
Timer::sleepMsec(1);
int64_t diff = sw.stop();
ASSERT_EQ(diff, 1);
}
TEST(METRICS_STOPWATCH, Long)
{
Stopwatch sw;
sw.start();
Timer::sleepMsec(100);
int64_t diff = sw.stop();
ASSERT_TRUE(diff >= 99 && diff <= 101);
}
int TextTestRunner::run(TestCase& testCase)
{
testCase.testResult.attach(this);
Stopwatch sw;
testCase.run();
std::cout << sw.stop() << " mus" << std::endl;
testCase.testResult.detach(this);
return testCase.testResult.total - testCase.testResult.successful;
}
