void ShmSystemV::Close() { ProfilerStart("close"); int result = shmdt(m_Buffer); ProfilerStop("close"); if (result < 1) { throw std::ios_base::failure( "ERROR: failed to detach shared memory segment of size " + std::to_string(m_Size) + " and name " + m_Name + ", in call to SystemV shmdt Close\n"); } if (m_RemoveAtClose) { ProfilerStart("close"); int remove = shmctl(m_ShmID, IPC_RMID, NULL); ProfilerStop("close"); if (result < 1) { throw std::ios_base::failure( "ERROR: failed to remove shared memory segment of size " + std::to_string(m_Size) + " and name " + m_Name + ", in call to SystemV shmctl Close\n"); } } m_IsOpen = false; }
static void rspamd_worker_term_handler (struct rspamd_worker_signal_handler *sigh, void *arg) { struct timeval tv; if (!sigh->worker->wanna_die) { rspamd_default_log_function (G_LOG_LEVEL_INFO, sigh->worker->srv->server_pool->tag.tagname, sigh->worker->srv->server_pool->tag.uid, G_STRFUNC, "terminating after receiving signal %s", g_strsignal (sigh->signo)); tv.tv_usec = 0; if (rspamd_worker_terminate_handlers (sigh->worker)) { tv.tv_sec = SOFT_SHUTDOWN_TIME; } else { tv.tv_sec = 0; } sigh->worker->wanna_die = 1; event_base_loopexit (sigh->base, &tv); #ifdef WITH_GPERF_TOOLS ProfilerStop (); #endif rspamd_worker_stop_accept (sigh->worker); } }
void int_handler(int sig_num) { #ifdef PROFILER ProfilerStop(); #endif exit(0); }
void ShmSystemV::Read(char *buffer, size_t size, size_t start) { CheckSizes(size, start, "in call to Read"); ProfilerStart("read"); std::memcpy(buffer, &m_Buffer[start], size); ProfilerStop("read"); }
void ShmSystemV::Write(const char *buffer, size_t size, size_t start) { CheckSizes(size, start, "in call to Write"); ProfilerStart("write"); std::memcpy(&m_Buffer[start], buffer, size); ProfilerStop("write"); }
int main(int argc, const char* argv[]) { char* alphabet; bool verbose = false; if (argc == 2 && strcmp(argv[1], "-v") != 0) { alphabet = (char*) argv[1]; } else if (argc == 3) { alphabet = (char*) argv[2]; verbose = true; } else { alphabet = (char*) "abcdefghijklmnopqrstuvwxyz"; } // char* alphabet = "abcdefghijklmnopqrstuvwxyz@"; // bool verbose = false; latin_square* my_square = malloc(sizeof(latin_square)); init_latin_square(alphabet, my_square); clock_t start = clock(); #ifdef profile ProfilerStart("/tmp/bees.prof"); #endif solve_latin_square(my_square, verbose); #ifdef profile ProfilerStop(); #endif if (!verbose) print_latin_square(my_square); clock_t end = clock(); return 0; }
// Stops the profiler. There are no request parameters. // This returns the profile output, it will also remain present // in the working directory. Future<http::Response> stop(const http::Request& request) { #ifdef HAS_GPERFTOOLS if (!started) { return http::BadRequest("Profiler not running.\n"); } LOG(INFO) << "Stopping Profiler"; ProfilerStop(); http::OK response; response.type = response.PATH; response.path = "perftools.out"; response.headers["Content-Type"] = "application/octet-stream"; response.headers["Content-Disposition"] = strings::format("attachment; filename=%s", PROFILE_FILE).get(); started = false; return response; #else return http::BadRequest( "Perftools is disabled. To enable perftools, " "configure libprocess with --enable-perftools.\n"); #endif }
int main(int argc, char** argv) { ProfilerStart(argv[0]); testing::InitGoogleTest(&argc, argv); int n = RUN_ALL_TESTS(); ProfilerStop(); return n; }
int main(int argc, char **argv) { int ret; ProfilerStart("mutool.prof"); ret = profiled_main(argc, argv); ProfilerStop(); return ret; }
void stop_tracing_here() { #ifdef GOOGLE_PROFILER ProfilerStop( ); impl::profile_handler(NULL); #ifdef VTRACE_SAMPLED VT_USER_END("sampling"); sample(); #endif #endif }
void ShmSystemV::Open(const std::string &name, const Mode openMode) { m_Name = name; CheckName(); m_OpenMode = openMode; // not using const key_t key = ftok(m_Name.c_str(), static_cast<int>(m_ProjectID)); switch (m_OpenMode) { case (Mode::Write): ProfilerStart("open"); m_ShmID = shmget(key, m_Size, IPC_CREAT | 0666); ProfilerStop("open"); break; case (Mode::Append): ProfilerStart("open"); m_ShmID = shmget(key, m_Size, 0); ProfilerStop("open"); break; case (Mode::Read): ProfilerStart("open"); m_ShmID = shmget(key, m_Size, 0); ProfilerStop("open"); break; default: throw std::invalid_argument( "ERROR: unknown open mode for shared memory segment " + m_Name + ", in call to SystemV Open"); } CheckShmID("in call to ShmSystemV shmget at Open"); m_Buffer = static_cast<char *>(shmat(m_ShmID, nullptr, 0)); CheckBuffer("in call to SystemV shmat at Open"); m_IsOpen = false; }
int main (int argc, char *argv[]) { gchar *prgdir, *localedir; GtkWidget *window, *vbox, *editor; prgdir = am_install_path (); if (prgdir) { localedir = g_build_filename (prgdir, AM_SYS_LOCALE_DIR, NULL); g_free (prgdir); } else { localedir = g_strdup (AM_SYS_LOCALE_DIR); } if (localedir) { setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, localedir); bind_textdomain_codeset (PACKAGE, "UTF-8"); textdomain (PACKAGE); g_free (localedir); } gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "amedit 0.0.1"); gtk_window_set_default_size (GTK_WINDOW (window), 600, 400); vbox = gtk_vbox_new (FALSE, FALSE); gtk_container_add (GTK_CONTAINER (window), vbox); editor = wiki_editor_new (NULL); gtk_box_pack_start (GTK_BOX (vbox), editor, TRUE, TRUE, 2); g_signal_connect (G_OBJECT (window), "destroy-event", G_CALLBACK (amedit_quit_ask), editor); g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (amedit_quit_ask), editor); gtk_widget_show_all (window); #ifdef AMBLOG_ENABLE_PROFILER ProfilerStart ("amblog.prof"); #endif gtk_main (); #ifdef AMBLOG_ENABLE_PROFILER ProfilerStop (); #endif return 0; }
int main(int argc, char* argv[]) { google::ParseCommandLineFlags(&argc, &argv, true); google::InitGoogleLogging(argv[0]); LOG(INFO) << "Running..."; nicopp::DataSet dset(std::move(nicopp::DataSet::Load("compiled/tagf","compiled/vf","compiled/linkf"))); #ifdef DEBUG ProfilerStart ("prof.out"); #endif /*{ long t = std::clock(); bool run = true; Graph g; g.total_weight = totalLink; int degreeTotal = 0; for(unsigned int i=0;i<nodes.size();i++){ nicopp::Node& node = nodes[i]; degreeTotal += node.neighbors().size(); g.degrees.emplace_back(degreeTotal); for(auto& kv : node.neighbors()){ g.links.emplace_back(kv.first); g.weights.emplace_back(kv.second); } } g.nb_links = g.links.size(); g.nb_nodes = nodes.size(); for(;run;){ int from = g.degrees.size(); Community c(g, 10, 0); LOG(INFO) << g.degrees.size() << " / " << g.links.size() << " / " << g.weights.size() << " <> " << c.size; run = c.one_level(); g = c.partition2graph_binary(); LOG(INFO) << from << " -> " << g.degrees.size() << " Nodes"; } LOG(INFO) << "Lap: " << (std::clock() - t); }*/ { long t = std::clock(); nicopp::TagGraph graph = dset.searchTag(0, 99999999999, 150000); for(int i=0;i<5;i++){ LOG(INFO) << graph.nodes().size() << " nodes / " << graph.edges() << " edges"; graph = std::move(graph.nextLevel(4, .0)); } LOG(INFO) << "Lap: " << (std::clock() - t); for (auto const& node : graph.nodes()){ LOG(INFO) << " Node: " << dset.tag(node.payload().tagId) << " / "<< node.selfLoops() << "/"<<node.degree(); } } #ifdef DEBUG ProfilerStop (); #endif return 0; }
int main(int argc, char** argv) { #ifdef PROFILER ProfilerStart("uwsgi_server.prof"); #endif stats s; tasks::net::acceptor<uwsgi_handler> srv(12345); auto tasks = std::vector<tasks::task*>{&srv, &s}; tasks::dispatcher::instance()->run(tasks); #ifdef PROFILER ProfilerStop(); #endif return 0; }
int main2() { ProfilerStart("test2.txt"); std::ifstream myfile; myfile.open("test.txt"); //myfile<<"wtf?"; //get_pilot_json("90376921","201407120000",myfile); //fclose(fp); get_json(myfile); std::cout << "!!!Hello World!!!" << std::endl; // prints !!!Hello World!!! myfile.close(); ProfilerStop(); return 0; }
static VALUE cpuprofiler_stop(VALUE self) { if (!bProfilerRunning) return Qfalse; bProfilerRunning = Qfalse; objprofiler_teardown(); methprofiler_teardown(); ProfilerStop(); ProfilerFlush(); return Qtrue; }
/** * returns number of milliseconds spent since _start() */ int mypaint_benchmark_end(void) { double time_spent = get_time() - g_start_time; g_start_time = 0.0; if (profiling_enabled()) { #ifdef HAVE_GPERFTOOLS ProfilerStop(); #else fprintf(stderr, "Warning: Not built with gperftools support.\n"); #endif } assert(time_spent*1000 < INT_MAX); return (int)(time_spent*1000); }
static void profilerSwitch(int signalNumber) { bool static started = false; if (!started) { if (ProfilerStart(FLAGS_profile_data_file.c_str())) { LOG(INFO) << "Profiler started"; } else { LOG(WARNING) << "Can't turn on cpu profiling for " << FLAGS_profile_data_file; } } else { ProfilerStop(); LOG(INFO) << "Profiler stopped"; } started = !started; }
int main() { #ifdef GPROF ProfilerStart("/tmp/scanner.prof"); #endif glimpse_init(); Glimpse_TypeAPI_init(); glimpse_pluginloader_path[0] = "."; glimpse_pluginloader_path[1] = ".."; glimpse_pluginloader_path[2] = NULL; glimpse_pluginloader_load_plugin("integer"); case0(); glimpse_cleanup(); #ifdef GPROF ProfilerStop(); #endif }
void ExternalProfiler::stop() { if (not this->can_profile) { log::log(MSG(err) << "Can not profile: gperftools is missing"); return; } if (not this->currently_profiling) { log::log(MSG(err) << "Profiler is not currently running"); return; } this->currently_profiling = false; #if WITH_GPERFTOOLS_PROFILER ProfilerStop(); #endif log::log(MSG(info) << "Profiler stopped; data written to " << this->profiling_filename); }
int main( int ac, char** av ) { try { #ifdef WIN32 _setmode( _fileno( stdout ), _O_BINARY ); #endif comma::command_line_options options( ac, av ); if( options.exists( "--help,-h" ) ) { usage(); } csv = comma::csv::options( options, "r,b,e" ); foreground_threshold = options.value( "--foreground-threshold", 1.0 ); min_points_per_partition = options.value( "--min-points-per-partition", 1u ); verbose = options.exists( "--verbose,-v" ); discard = options.exists( "--discard,-d" ); output_all = options.exists( "--output-all" ); ::tbb::filter_t< block_t*, block_t* > partition_filter( ::tbb::filter::serial_in_order, &partition_ ); ::tbb::filter_t< block_t*, void > write_filter( ::tbb::filter::serial_in_order, &write_block_ ); #ifdef PROFILE ProfilerStart( "points-foreground-partitions.prof" ); { #endif if( discard ) { bursty_reader.reset( new snark::tbb::bursty_reader< block_t* >( &read_block_bursty_ ) ); ::tbb::filter_t< void, void > filters = bursty_reader->filter() & partition_filter & write_filter; ::tbb::parallel_pipeline( 3, filters ); // while( bursty_reader->wait() ) { ::tbb::parallel_pipeline( 3, filters ); } bursty_reader->join(); } else { ::tbb::filter_t< void, block_t* > read_filter( ::tbb::filter::serial_in_order, &read_block_ ); ::tbb::filter_t< void, void > filters = read_filter & partition_filter & write_filter; ::tbb::parallel_pipeline( 3, filters ); } #ifdef PROFILE ProfilerStop(); } #endif if( is_shutdown ) { std::cerr << "points-foreground-partitions: caught signal" << std::endl; } else { std::cerr << "points-foreground-partitions: end of stream" << std::endl; } return 0; } catch( std::exception& ex ) { std::cerr << "points-foreground-partitions: " << ex.what() << std::endl; } catch( ... ) { std::cerr << "points-foreground-partitions: unknown exception" << std::endl; } return 1; }
int main(int argc, const char* argv[]) { SDLInterfaceInitData sdlInitData; std::vector < std::string > opts; for (int i = 0; i < argc; i++) { opts.push_back(std::string(argv[i])); } // running fullscreen is default sdlInitData.Fullscreen = false; bool runDemoMode = false; bool muted = false; bool forwardScroll = false; bool withIntro = false; /* if (commandline::handleCommandLine(sdlInitData, opts, runDemoMode, muted, forwardScroll, withIntro) == false) return 0;*/ DescentFramework f(false, runDemoMode, muted, forwardScroll, withIntro, true); f.initRenderEngine(sdlInitData); // todo: make this a lot nicer, by templating the FW class #ifdef USE_PROFILER ProfilerStart("GameLoop.perf"); #endif f.execute(); #ifdef USE_PROFILER ProfilerStop(); #endif // done globally here for all used SDL systems; SDL_Quit(); return 0; }
bool AdminRequestHandler::handleCPUProfilerRequest(const std::string &cmd, Transport *transport) { string file = RuntimeOption::ProfilerOutputDir + "/" + Process::HostName + "/hphp.prof"; if (cmd == "prof-cpu-on") { if (Util::mkdir(file)) { ProfilerStart(file.c_str()); transport->sendString("OK\n"); } else { transport->sendString("Unable to mkdir for profile data.\n"); } return true; } if (cmd == "prof-cpu-off") { ProfilerStop(); ProfilerFlush(); transport->sendString("OK\n"); return true; } return false; }
int main( int argc, char ** argv ) { #ifdef GOOGLEPROF ProfilerStart("test.prof"); #endif // parse command line if ( argc > 1 ){ time_to_run_s = atoi(argv[1]); } if ( argc > 2 ){ thread_count = atoi(argv[2]); } printf("SIOX threaded performance test, please run it with and without SIOX instrumentation !\n"); printf("Parameters: %d threads, %d seconds\n", thread_count, time_to_run_s); pthread_barrier_init( & barrier, NULL, thread_count ); pthread_t thread[thread_count]; for(int i=0; i < thread_count; i++){ pthread_create(& thread[i], NULL, threadFunc, (void * restrict) i); } for(int i=0; i < thread_count; i++){ void * data; pthread_join(thread[i], & data); } pthread_barrier_destroy( & barrier ); #ifdef GOOGLEPROF ProfilerStop("test.prof"); #endif return 0; }
void bigDictTest() { SmartKey::SmartKeyDictionary dictionary(g_settings); #ifdef HEAP HeapProfilerStart("smartkey"); HeapProfilerDump("period"); #endif dictionary.loadSkippedCharsFromFile("/var/tmp/key_skipped"); #ifdef HEAP HeapProfilerDump("period"); #endif dictionary.loadTermsFromFile("/var/tmp/key_dict_us"); //dictionary.loadCompiledDictionary("/var/tmp/compiled_key_dict_us"); //HeapProfilerDump("period"); dictionary.loadEquivalencesFromFile("/var/tmp/key_equiv"); //testExactMatchesInFile(dictionary, "/var/tmp/key_dict_us"); // old test /* int numInserts = 0; dictionary.insert("dork", 69); numInserts++; dictionary.insert("door", 67); numInserts++; dictionary.insert("doored", 39); numInserts++; dictionary.insert("flake", 70); numInserts++; dictionary.insert("the", 90); numInserts++; dictionary.insert("that", 90); numInserts++; dictionary.insert("they", 80); numInserts++; dictionary.insert("there", 82); numInserts++; dictionary.insert("There's", 81); numInserts++; dictionary.insert("at", 90); numInserts++; dictionary.insert("it", 91); numInserts++; dictionary.insert("for", 69); numInserts++; dictionary.insert("attempt", 30); numInserts++; dictionary.insert("substantial", 43); numInserts++; dictionary.insert("subs", 2); numInserts++; dictionary.insert("nonsense", 4); numInserts++; dictionary.print(); */ allWordsTest(dictionary); // small tree insertion test /* std::string there = "there"; std::string theres = "theres"; std::string therr = "therr"; std::string rhsy = "rhsy"; std::string that = "that"; std::string that_rgsr = "rgsy"; dictionary.find(there); dictionary.find(therr); dictionary.find(that); dictionary.find(that_rgsr); dictionary.find(theres); dictionary.find(std::string("fot")); dictionary.find(std::string("ot")); dictionary.find(std::string("dindrsmrusl")); */ /* //tiny test printf("---- inserting ------\n"); dictionary.insert("that", 80); dictionary.print(); printf("---- inserting ------\n"); dictionary.insert("there", 90); dictionary.print(); printf("---- inserting ------\n"); dictionary.insert("they", 70); dictionary.print(); printf("---- inserting ------\n"); dictionary.insert("that's", 70); dictionary.print(); */ /* weird ordering issue dictionary.insert("theater", 2); dictionary.insert("theaters", 3); dictionary.insert("there", 2); dictionary.insert("the", 1); dictionary.insert("Theme", 4); dictionary.insert("Thematic", 1); dictionary.insert("Th", 10); dictionary.insert("those", 1); */ //dictionary.print(); //test(dictionary, "there", "there"); #ifdef HEAP ProfilerStart("smartkeyCpu"); #endif /* test(dictionary, "tha", "that"); test(dictionary, "rgru", "they"); test(dictionary, "subs", "sub's"); test(dictionary, "substanti", "substantial"); test(dictionary, "mimdrbdr", "nonsense"); */ #ifdef HEAP ProfilerStop(); #endif //dictionary.insert("the", 100000); int size = 0; int numOfSize = -1; printf("%s: number of nodes: %d\n", __FUNCTION__, dictionary.getNodeCount()); while (numOfSize != 0) { int capacity = 0; numOfSize = dictionary.singlesCounter(size, capacity); printf("%s: number of child maps with only %d child: %d\n", __FUNCTION__, size, numOfSize); size++; } printf("%s: num removable nodes: %d\n", __FUNCTION__, dictionary.numRemovableNodes()); printf("%s: node size: %d\n", __FUNCTION__, sizeof(SmartKeyNode)); }
void StopProfiling::executePlanOperation() { #ifdef HYRISE_USE_GOOGLE_PROFILER ProfilerStop(); #endif output = input; }
int main(int argc, char *argv[]) { isc_result_t result; #ifdef HAVE_LIBSCF char *instance = NULL; #endif #ifdef HAVE_GPERFTOOLS_PROFILER (void) ProfilerStart(NULL); #endif /* * Record version in core image. * strings named.core | grep "named version:" */ strlcat(version, #if defined(NO_VERSION_DATE) || !defined(__DATE__) "named version: BIND " VERSION " <" SRCID ">", #else "named version: BIND " VERSION " <" SRCID "> (" __DATE__ ")", #endif sizeof(version)); result = isc_file_progname(*argv, program_name, sizeof(program_name)); if (result != ISC_R_SUCCESS) ns_main_earlyfatal("program name too long"); if (strcmp(program_name, "lwresd") == 0) ns_g_lwresdonly = ISC_TRUE; if (result != ISC_R_SUCCESS) ns_main_earlyfatal("failed to build internal symbol table"); isc_assertion_setcallback(assertion_failed); isc_error_setfatal(library_fatal_error); isc_error_setunexpected(library_unexpected_error); ns_os_init(program_name); dns_result_register(); dst_result_register(); isccc_result_register(); #ifdef PKCS11CRYPTO pk11_result_register(); #endif parse_command_line(argc, argv); pfilter_open(); /* * Warn about common configuration error. */ if (ns_g_chrootdir != NULL) { int len = strlen(ns_g_chrootdir); if (strncmp(ns_g_chrootdir, ns_g_conffile, len) == 0 && (ns_g_conffile[len] == '/' || ns_g_conffile[len] == '\\')) ns_main_earlywarning("config filename (-c %s) contains " "chroot path (-t %s)", ns_g_conffile, ns_g_chrootdir); } result = isc_mem_create(0, 0, &ns_g_mctx); if (result != ISC_R_SUCCESS) ns_main_earlyfatal("isc_mem_create() failed: %s", isc_result_totext(result)); isc_mem_setname(ns_g_mctx, "main", NULL); setup(); /* * Start things running and then wait for a shutdown request * or reload. */ do { result = isc_app_run(); if (result == ISC_R_RELOAD) { ns_server_reloadwanted(ns_g_server); } else if (result != ISC_R_SUCCESS) { UNEXPECTED_ERROR(__FILE__, __LINE__, "isc_app_run(): %s", isc_result_totext(result)); /* * Force exit. */ result = ISC_R_SUCCESS; } } while (result != ISC_R_SUCCESS); #ifdef HAVE_LIBSCF if (ns_smf_want_disable == 1) { result = ns_smf_get_instance(&instance, 1, ns_g_mctx); if (result == ISC_R_SUCCESS && instance != NULL) { if (smf_disable_instance(instance, 0) != 0) UNEXPECTED_ERROR(__FILE__, __LINE__, "smf_disable_instance() " "failed for %s : %s", instance, scf_strerror(scf_error())); } if (instance != NULL) isc_mem_free(ns_g_mctx, instance); } #endif /* HAVE_LIBSCF */ cleanup(); if (want_stats) { isc_mem_stats(ns_g_mctx, stdout); isc_mutex_stats(stdout); } if (ns_g_memstatistics && memstats != NULL) { FILE *fp = NULL; result = isc_stdio_open(memstats, "w", &fp); if (result == ISC_R_SUCCESS) { isc_mem_stats(ns_g_mctx, fp); isc_mutex_stats(fp); isc_stdio_close(fp); } } isc_mem_destroy(&ns_g_mctx); isc_mem_checkdestroyed(stderr); ns_main_setmemstats(NULL); isc_app_finish(); ns_os_closedevnull(); ns_os_shutdown(); #ifdef HAVE_GPERFTOOLS_PROFILER ProfilerStop(); #endif return (0); }
void tarjan_run (run_t *run, wctx_t *ctx) { alg_local_t *loc = ctx->local; raw_data_t *addr; raw_data_t state_data; bool on_stack; hash32_t hash; #ifdef HAVE_PROFILER Warning (info, "Using the profiler"); ProfilerStart ("tarjan.perf"); #endif #ifdef SEARCH_COMPLETE_GRAPH int init_state = dlopen_get_worker_initial_state (ctx->id, W); int inits = 0; // loop until every state of the graph has been visited while ( 1 ) { inits ++; // use loc->target as a dummy for the initial state loc->target->ref = init_state; #endif tarjan_init (ctx); // continue until we are done exploring the graph while ( !run_is_stopped (run) ) { state_data = dfs_stack_top (loc->search_stack); if (state_data != NULL) { // there is a state on the current stackframe ==> explore it state_info_deserialize (ctx->state, state_data); // pop the state and continue if it is part of a completed SCC if (state_store_has_color (ctx->state->ref, SCC_STATE, 0)) { dfs_stack_pop (loc->search_stack); continue; } hash = ref_hash (ctx->state->ref); on_stack = fset_find (loc->visited_states, &hash, &ctx->state->ref, (void **) &addr, true); if (!on_stack) { // unseen state ==> initialize and explore HREassert (loc->cnt.tarjan_counter != UINT32_MAX); loc->cnt.tarjan_counter ++; loc->state_tarjan.index = loc->cnt.tarjan_counter; loc->state_tarjan.lowlink = loc->cnt.tarjan_counter; // point visited_states data to stack *addr = state_data; explore_state (ctx); state_info_serialize (ctx->state, state_data); } else { // previously visited state ==> update parent // NB: state is on tarjan_stack state_info_deserialize (ctx->state, *addr); update_parent (ctx, loc->state_tarjan.lowlink); dfs_stack_pop (loc->search_stack); } } else { // there is no state on the current stackframe ==> backtrack // we are done if we backtrack from the initial state if (0 == dfs_stack_nframes (loc->search_stack)) break; // leave the stackframe dfs_stack_leave (loc->search_stack); ctx->counters->level_cur--; // retrieve the parent state from search_stack (to be removed) state_data = dfs_stack_top (loc->search_stack); state_info_deserialize (ctx->state, state_data); Debug ("Backtracking %zu (%d, %d)", ctx->state->ref, loc->state_tarjan.index, loc->state_tarjan.lowlink); if (loc->state_tarjan.index == loc->state_tarjan.lowlink) { // index == lowlink ==> root of the SCC ==> report the SCC pop_scc (ctx, ctx->state->ref, loc->state_tarjan.lowlink); } else { // lowlink < index ==> LIVE SCC ==> move to tarjan_stack move_tarjan (ctx, ctx->state, state_data); update_parent (ctx, loc->state_tarjan.lowlink); } dfs_stack_pop (loc->search_stack); } } #ifdef SEARCH_COMPLETE_GRAPH init_state = dlopen_get_new_initial_state (init_state); if (init_state == -1) { Warning(info, "Number of inits : %d", inits); break; } } #endif #ifdef HAVE_PROFILER Warning(info, "Done profiling"); ProfilerStop(); #endif if (!run_is_stopped(run) && dfs_stack_size(loc->tarjan_stack) != 0) Warning (info, "Tarjan stack not empty: %zu (stack %zu)", dfs_stack_size(loc->tarjan_stack), dfs_stack_size(loc->search_stack)); if (!run_is_stopped(run) && fset_count(loc->visited_states) != 0) Warning (info, "Stack-set not empty: %zu", fset_count(loc->visited_states)); }
int main(int argc, const char *argv[]) { fake * fk = newfake(); // 解析参数 int parseret = parsearg(fk, argc, argv); if (parseret != 0) { return parseret; } if (g_iscompiled) { fksetargv(fk, argc - 1, argv + 1); } else { fksetargv(fk, argc - 2, argv + 2); } fkopenalllib(fk); fkseterrorfunc(fk, error_log); // for test fkreg(fk, "test_cfunc1", test_cfunc1); fkreg(fk, "new_test_class1", new_test_class1); fkreg(fk, "new_test_class2", new_test_class2); fkreg(fk, "delete_test_class1", delete_test_class1); fkreg(fk, "delete_test_class2", delete_test_class2); fkreg(fk, "test_memfunc1", &test_class1::test_memfunc1); fkreg(fk, "test_memfunc1", &test_class2::test_memfunc1); fkreg(fk, "test_memfunc2", &test_class2::test_memfunc2); // 编译后文件 if (g_iscompiled) { // 打开自己 char * selftmpbuf = 0; int selfsize = 0; if (!readfile(g_selfname, 0, selftmpbuf, selfsize)) { return -1; } int startpos = 0; int size = 0; memcpy(&startpos, g_replacebuff, sizeof(startpos)); memcpy(&size, g_replacebuff + 4, sizeof(size)); if (fkloadfunc(fk, selftmpbuf + startpos, size) == -1) { printf("load func fail\n"); return -1; } free(selftmpbuf); } // 解析文件 else if (!g_isload) { fkparse(fk, argv[1]); if (fkerror(fk)) { return -1; } } // 读文件 else { // 读文件 char * tmpbuf = 0; int size = 0; if (!readfile(argv[1], 0, tmpbuf, size)) { return -1; } if (fkloadfunc(fk, tmpbuf, size) == -1) { printf("load func fail\n"); return -1; } free(tmpbuf); printf("load from %s ok, size %d\n", argv[1], size); } // 存文件 if (g_issave) { int tmpsize = 1024 * 1024; char * tmpbuf = (char *)malloc(tmpsize); int size = fksavefunc(fk, tmpbuf, tmpsize); if (size == -1) { printf("save func fail\n"); return -1; } const char * filename = "fake.bin"; if (!writefile(filename, tmpbuf, size)) { return -1; } free(tmpbuf); printf("save to %s ok, size %d\n", filename, size); return 0; } // 编译到一起 if (g_iscompile) { int tmpsize = 1024 * 1024; char * tmpbuf = (char *)malloc(tmpsize); int size = fksavefunc(fk, tmpbuf, tmpsize); if (size == -1) { printf("compile func fail\n"); return -1; } // 打开自己 char * selftmpbuf = 0; int selfsize = 0; if (!readfile(g_selfname, size, selftmpbuf, selfsize)) { return -1; } // 替换内存中的字符串 bool isfind = false; for (int i = 0; i < selfsize; i++) { if (memcmp(selftmpbuf + i, g_replacebuff, strlen(g_replacebuff)) == 0) { memcpy(selftmpbuf + i, &selfsize, sizeof(selfsize)); memcpy(selftmpbuf + i + 4, &size, sizeof(size)); isfind = true; break; } } if (!isfind) { printf("replace %s pos fail\n", argv[0]); return -1; } // 复制后面的 memcpy(selftmpbuf + selfsize, tmpbuf, size); free(tmpbuf); // 输出 const char * filename = "out.exe"; if (!writefile(filename, selftmpbuf, selfsize + size)) { return -1; } free(selftmpbuf); printf("compile to %s ok, size %d\n", filename, selfsize + size); return 0; } #ifndef WIN32 if (g_isopengoogleprofile) { ProfilerStart("fake.prof"); } #endif uint32_t begintime = time(0); int fkret = 0; // run for (int i = 0; i < g_testnum; i++) { if (!g_isopenjit) { if (g_isstep) { fkret = fkdebugrun<int>(fk, "main"); } else { fkret = fkrun<int>(fk, "main"); } } else { fkret = fkrunjit<int>(fk, "main"); } } uint32_t endtime = time(0); #ifndef WIN32 if (g_isopengoogleprofile) { ProfilerStop(); } #endif if (fkerror(fk)) { return -1; } if (g_isopenprofile) { printf("\n%s", fkdumpprofile(fk)); } if (g_isprintoutput) { printf("main return : %d, use time %d\n", fkret, endtime - begintime); } delfake(fk); return 0; }
void PProfService::profile( ::google::protobuf::RpcController* controller_base, const ::brpc::ProfileRequest* /*request*/, ::brpc::ProfileResponse* /*response*/, ::google::protobuf::Closure* done) { ClosureGuard done_guard(done); Controller* cntl = static_cast<Controller*>(controller_base); cntl->http_response().set_content_type("text/plain"); if ((void*)ProfilerStart == NULL || (void*)ProfilerStop == NULL) { cntl->SetFailed(ENOMETHOD, "%s, to enable cpu profiler, check out " "docs/cn/cpu_profiler.md", berror(ENOMETHOD)); return; } int sleep_sec = ReadSeconds(cntl); if (sleep_sec <= 0) { if (!cntl->Failed()) { cntl->SetFailed(EINVAL, "You have to specify ?seconds=N. If you're " "using pprof, add --seconds=N"); } return; } // Log requester std::ostringstream client_info; client_info << cntl->remote_side(); if (cntl->auth_context()) { client_info << "(auth=" << cntl->auth_context()->user() << ')'; } else { client_info << "(no auth)"; } LOG(INFO) << client_info.str() << " requests for cpu profile for " << sleep_sec << " seconds"; char prof_name[256]; if (MakeProfName(PROFILING_CPU, prof_name, sizeof(prof_name)) != 0) { cntl->SetFailed(errno, "Fail to create .prof file, %s", berror()); return; } butil::File::Error error; const butil::FilePath dir = butil::FilePath(prof_name).DirName(); if (!butil::CreateDirectoryAndGetError(dir, &error)) { cntl->SetFailed(EPERM, "Fail to create directory=`%s'",dir.value().c_str()); return; } if (!ProfilerStart(prof_name)) { cntl->SetFailed(EAGAIN, "Another profiler is running, try again later"); return; } if (bthread_usleep(sleep_sec * 1000000L) != 0) { PLOG(WARNING) << "Profiling has been interrupted"; } ProfilerStop(); butil::fd_guard fd(open(prof_name, O_RDONLY)); if (fd < 0) { cntl->SetFailed(ENOENT, "Fail to open %s", prof_name); return; } butil::IOPortal portal; portal.append_from_file_descriptor(fd, ULONG_MAX); cntl->response_attachment().swap(portal); }