//------------------------------------------------------------------------------ // 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(); }
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); }
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(); }
void testTimerHandler() { LOGT("<testTimerHandler>"); Timer t1, t2; TimerHandler handler; handler.attach(t1, timeout1); handler.attach(t2, timeout2); t1.setInterval(1); t2.setInterval(2); sw1.start(); sw2.start(); t1.start(); t2.start(); Thread::sleep(15); handler.detach(t2); Thread::sleep(30); t1.stop(); t2.stop(); Thread::sleep(105); }
//-------------------------------------------------------------------------- // 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 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); }
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; }
bool await(const process::Future<T>& future, const Duration& duration) { if (!process::Clock::paused()) { return future.await(duration); } // If the clock is paused, no new timers will expire. // Future::await(duration) may hang forever because it depends on // a timer to expire after 'duration'. We instead ensure all // expired timers are flushed and check if the future is satisfied. Stopwatch stopwatch; stopwatch.start(); // Settle to make sure all expired timers are executed (not // necessarily finished, see below). process::Clock::settle(); while (future.isPending() && stopwatch.elapsed() < duration) { // Synchronous operations and asynchronous process::Process // operations should finish when the above 'settle()' returns. // Other types of async operations such as io::write() may not. // Therefore we wait the specified duration for it to complete. // Note that nothing prevents the operations to schedule more // timeouts for some time in the future. These timeouts will // never be executed due to the paused process::Clock. In this // case we return after the stopwatch (system clock) runs out. os::sleep(Milliseconds(10)); } return !future.isPending(); }
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 resourceOffers(const vector<Offer>& offers, const vector<string>& pids) { if (aborted) { VLOG(1) << "Ignoring resource offers message because " << "the driver is aborted!"; return; } VLOG(2) << "Received " << offers.size() << " offers"; CHECK(offers.size() == pids.size()); // Save the pid associated with each slave (one per offer) so // later we can send framework messages directly. for (size_t i = 0; i < offers.size(); i++) { UPID pid(pids[i]); // Check if parse failed (e.g., due to DNS). if (pid != UPID()) { VLOG(3) << "Saving PID '" << pids[i] << "'"; savedOffers[offers[i].id()][offers[i].slave_id()] = pid; } else { VLOG(1) << "Failed to parse PID '" << pids[i] << "'"; } } Stopwatch stopwatch; if (FLAGS_v >= 1) { stopwatch.start(); } scheduler->resourceOffers(driver, offers); VLOG(1) << "Scheduler::resourceOffers took " << stopwatch.elapsed(); }
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() { Stopwatch sw; sw.start(); size_t n = 600851475143; size_t z = n; vector<size_t> factors; size_t s = static_cast<size_t>(sqrt(n)); for (size_t i = 2; i <= s; i++) { if (z % i == 0) { factors.push_back(i); z /= i; i = 2; } if (i == s && z != 1) { factors.push_back(z); } } cout << strjoin(factors, " * ") << endl; cout << sw.get(); return 0; }
auto_release_ptr<CurveObject> CurveObjectReader::load_curve_file( const SearchPaths& search_paths, const char* name, const ParamArray& params) { auto_release_ptr<CurveObject> object = CurveObjectFactory::create(name, params); const string filepath = search_paths.qualify(params.get<string>("filepath")); const size_t split_count = params.get_optional<size_t>("presplits", 0); ifstream input; input.open(filepath.c_str()); if (!input.is_open()) { RENDERER_LOG_ERROR("failed to open curve file %s.", filepath.c_str()); return object; } Stopwatch<DefaultWallclockTimer> stopwatch; stopwatch.start(); size_t curve1_count; size_t curve3_count; input >> curve1_count; input >> curve3_count; object->reserve_curves1(curve1_count); object->reserve_curves3(curve3_count); for (size_t c = 0; c < curve1_count + curve3_count; ++c) { size_t control_point_count; input >> control_point_count; if (control_point_count != 2 && control_point_count != 4) { RENDERER_LOG_ERROR( "while loading curve file %s: only linear curves (2 control points) or cubic curves (4 control points) are currently supported.", filepath.c_str()); return object; } if (control_point_count == 2) { GVector3 points[2]; GScalar widths[2]; for (size_t p = 0; p < control_point_count; ++p) { input >> points[p].x >> points[p].y >> points[p].z; input >> widths[p]; } // We never presplit degree-1 curves. const CurveType1 curve(points, widths); object->push_curve1(curve); } else {
CurveTree::CurveTree(const Arguments& arguments) : TreeType(AlignedAllocator<void>(System::get_l1_data_cache_line_size())) , m_arguments(arguments) { // Retrieve construction parameters. const MessageContext message_context( format("while building curve tree for assembly \"{0}\"", m_arguments.m_assembly.get_path())); const ParamArray& params = m_arguments.m_assembly.get_parameters().child("acceleration_structure"); const string algorithm = params.get_optional<string>("algorithm", "bvh", make_vector("bvh", "sbvh"), message_context); const double time = params.get_optional<double>("time", 0.5); // Start stopwatch. Stopwatch<DefaultWallclockTimer> stopwatch; stopwatch.start(); // Build the tree. Statistics statistics; if (algorithm == "bvh") build_bvh(params, time, statistics); else throw ExceptionNotImplemented(); // Print curve tree statistics. statistics.insert_size("nodes alignment", alignment(&m_nodes[0])); statistics.insert_time("total time", stopwatch.measure().get_seconds()); RENDERER_LOG_DEBUG("%s", StatisticsVector::make( "curve tree #" + to_string(m_arguments.m_curve_tree_uid) + " statistics", statistics).to_string().c_str()); }
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 generate() { watch.start(); while (true) { Duration elapsed = watch.elapsed(); if (duration.isSome() && elapsed >= duration.get()) { LOG(INFO) << "LoadGenerator generated " << messages << " messages in " << elapsed << " (throughput = " << (messages / elapsed.secs()) << " messages/sec)"; LOG(INFO) << "Stopping LoadGenerator and scheduler driver"; terminate(self()); driver->stop(); return; } Stopwatch reconcile; reconcile.start(); driver->reconcileTasks(vector<TaskStatus>()); messages++; // Compensate for the driver call overhead. os::sleep(std::max( Duration::zero(), Seconds(1) / qps - reconcile.elapsed())); } }
TEST_P(Registrar_BENCHMARK_Test, performance) { Registrar registrar(flags, state); AWAIT_READY(registrar.recover(master)); vector<SlaveInfo> infos; Attributes attributes = Attributes::parse("foo:bar;baz:quux"); Resources resources = Resources::parse("cpus(*):1.0;mem(*):512;disk(*):2048").get(); size_t slaveCount = GetParam(); // Create slaves. for (size_t i = 0; i < slaveCount; ++i) { // Simulate real slave information. SlaveInfo info; info.set_hostname("localhost"); info.mutable_id()->set_value( std::string("201310101658-2280333834-5050-48574-") + stringify(i)); info.mutable_resources()->MergeFrom(resources); info.mutable_attributes()->MergeFrom(attributes); infos.push_back(info); } // Admit slaves. Stopwatch watch; watch.start(); Future<bool> result; foreach (const SlaveInfo& info, infos) { result = registrar.apply(Owned<Operation>(new AdmitSlave(info))); }
void lostSlave(const SlaveID& slaveId) { if (aborted) { VLOG(1) << "Ignoring lost slave message because the driver is aborted!"; return; } if (from != master) { LOG(WARNING) << "Ignoring lost slave message from " << from << "because it is not from the registered master (" << master << ")"; return; } VLOG(1) << "Lost slave " << slaveId; savedSlavePids.erase(slaveId); Stopwatch stopwatch; if (FLAGS_v >= 1) { stopwatch.start(); } scheduler->slaveLost(driver, slaveId); VLOG(1) << "Scheduler::slaveLost took " << stopwatch.elapsed(); }
bool MeshObjectWriter::write( const MeshObject& object, const char* object_name, const char* filename) { assert(filename); Stopwatch<DefaultWallclockTimer> stopwatch; stopwatch.start(); try { GenericMeshFileWriter writer(filename); MeshObjectWalker walker(object, object_name); writer.write(walker); } catch (const exception& e) { RENDERER_LOG_ERROR( "failed to write mesh file %s: %s.", filename, e.what()); return false; } stopwatch.measure(); RENDERER_LOG_INFO( "wrote mesh file %s in %s.", filename, pretty_time(stopwatch.get_seconds()).c_str()); return true; }
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 RegistrarProcess::update() { if (operations.empty()) { return; // No-op. } CHECK(!updating); CHECK(error.isNone()); CHECK_SOME(variable); // Time how long it takes to apply the operations. Stopwatch stopwatch; stopwatch.start(); updating = true; // Create a snapshot of the current registry. Registry registry = variable.get().get(); // Create the 'slaveIDs' accumulator. hashset<SlaveID> slaveIDs; foreach (const Registry::Slave& slave, registry.slaves().slaves()) { slaveIDs.insert(slave.info().id()); } foreach (Owned<Operation> operation, operations) { // No need to process the result of the operation. (*operation)(®istry, &slaveIDs, flags.registry_strict); }
Ref<Image> Image::load_from_data (const Ptr<IData> data) { static Stopwatch t; static unsigned count = 0; ++count; Ref<Image> loaded_image; Shared<Buffer> buffer; t.start(); buffer = data->buffer(); switch (buffer->mimetype()) { case IMAGE_JPEG: loaded_image = load_jpeg_image(data); break; case IMAGE_PNG: loaded_image = load_png_image(data); break; //case Data::IMAGE_DDS: // loaded_image = load_ddsimage(data); default: logger()->log(LOG_ERROR, "Could not load image: Unsupported image format."); } t.pause(); logger()->log(LOG_INFO, LogBuffer() << "*** Total time to load " << count << " images: " << t.time() << "s"); return loaded_image; }
Try<Action> LevelDBStorage::read(uint64_t position) { Stopwatch stopwatch; stopwatch.start(); leveldb::ReadOptions options; string value; leveldb::Status status = db->Get(options, encode(position), &value); if (!status.ok()) { return Error(status.ToString()); } google::protobuf::io::ArrayInputStream stream(value.data(), value.size()); Record record; if (!record.ParseFromZeroCopyStream(&stream)) { return Error("Failed to deserialize record"); } if (record.type() != Record::ACTION) { return Error("Bad record"); } LOG(INFO) << "Reading position from leveldb took " << stopwatch.elapsed(); return record.action(); }
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 reregistered(const FrameworkID& frameworkId, const MasterInfo& masterInfo) { if (aborted) { VLOG(1) << "Ignoring framework re-registered message because " << "the driver is aborted!"; return; } if (connected) { VLOG(1) << "Ignoring framework re-registered message because " << "the driver is already connected!"; return; } VLOG(1) << "Framework re-registered with " << frameworkId; CHECK(framework.id() == frameworkId); connected = true; failover = false; Stopwatch stopwatch; if (FLAGS_v >= 1) { stopwatch.start(); } scheduler->reregistered(driver, masterInfo); VLOG(1) << "Scheduler::reregistered took " << stopwatch.elapsed(); }
Try<Nothing> LevelDBStorage::persist(const Metadata& metadata) { Stopwatch stopwatch; stopwatch.start(); leveldb::WriteOptions options; options.sync = true; Record record; record.set_type(Record::METADATA); record.mutable_metadata()->CopyFrom(metadata); string value; if (!record.SerializeToString(&value)) { return Error("Failed to serialize record"); } leveldb::Status status = db->Put(options, encode(0, false), value); if (!status.ok()) { return Error(status.ToString()); } LOG(INFO) << "Persisting metadata (" << value.size() << " bytes) to leveldb took " << stopwatch.elapsed(); return Nothing(); }
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 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(); }
bool Frame::write_image( const char* file_path, const Image& image, const ImageAttributes& image_attributes) const { assert(file_path); Image final_image(image); transform_to_output_color_space(final_image); Stopwatch<DefaultWallclockTimer> stopwatch; stopwatch.start(); try { try { GenericImageFileWriter writer; writer.write(file_path, final_image, image_attributes); } catch (const ExceptionUnsupportedFileFormat&) { const string extension = lower_case(filesystem::path(file_path).extension()); RENDERER_LOG_ERROR( "file format '%s' not supported, writing the image in OpenEXR format " "(but keeping the filename unmodified).", extension.c_str()); EXRImageFileWriter writer; writer.write(file_path, final_image, image_attributes); } } catch (const ExceptionIOError&) { RENDERER_LOG_ERROR( "failed to write image file %s: i/o error.", file_path); return false; } catch (const Exception& e) { RENDERER_LOG_ERROR( "failed to write image file %s: %s.", file_path, e.what()); return false; } stopwatch.measure(); RENDERER_LOG_INFO( "wrote image file %s in %s.", file_path, pretty_time(stopwatch.get_seconds()).c_str()); return true; }