// compare using tsc and `clock_gettime` for benchmarking code.
void bench_tsc_clock(unsigned int fibn)
{
printf("=> TSC Vs. Clock accuray (need to adjust TSC freq to machine)\n");
printf("Testing `fib(%d)`\n", fibn);
uint64_t t0, t1;
int i;
t0 = bench_start();
for (i = 0; i < N; i++) {
fib(fibn);
}
t1 = bench_start();
printf("TSC : %" PRIu64 " cycles\n", (t1 - t0 - tsc_overhead) / N);
printf("TSC : %" PRIu64 " ns\n", cycles_to_ns((t1 - t0 - tsc_overhead) / N));
t0 = clock_ns();
for (i = 0; i < N; i++) {
fib(fibn);
}
t1 = clock_ns();
printf("CLOCK: %" PRIu64 " ns\n", (t1 - t0 - clk_overhead) / N);
printf("\n=> TSC Vs. Clock call-cost\n");
printf("TSC : %" PRIu64 " cycles\n", tsc_overhead);
printf("CLOCK: %" PRIu64 " cycles\n\n", clk_overhead);
}
// evaluate cost of recursive fibonacci calculation
void bench_fib()
{
uint64_t t0, t1;
int i;
t0 = bench_start();
for (i = 0; i < N; i++) {
fib(10);
}
t1 = bench_start();
printf("Fib (10): %" PRIu64 " clock cycles\n",
(t1 - t0 - tsc_overhead) / N);
}
url
resolve_tex (url name) {
string s= as_string (name);
if (is_cached ("font_cache.scm", s)) {
url u= url_system (cache_get ("font_cache.scm", s) -> label);
if (exists (u)) return u;
cache_reset ("font_cache.scm", s);
}
bench_start ("resolve tex");
url u= url_none ();
if (ends (s, "mf" )) {
u= resolve_tfm (name);
#ifdef OS_WIN32
if (is_none (u))
u= resolve_tfm (replace (s, ".mf", ".tfm"));
#endif
}
if (ends (s, "tfm")) u= resolve_tfm (name);
if (ends (s, "pk" )) u= resolve_pk (name);
if (ends (s, "pfb")) u= resolve_pfb (name);
bench_cumul ("resolve tex");
if (!is_none (u)) cache_set ("font_cache.scm", s, as_string (u));
//cout << "Resolve " << name << " -> " << u << "\n";
return u;
}
int
main (int argc, char ** argv)
{
stinger_t * S = stinger_new();
/* insert your data now */
load_benchmark_data_into_stinger (S, argv[1],0);
/* get number of vertices */
uint64_t nv = stinger_max_active_vertex (S);
nv++;
print_fragmentation_stats (S, nv);
/* auxiliary data structure */
double * pagerank_scores = xmalloc (nv * sizeof(int64_t));
double * pagerank_scores_tmp = xmalloc (nv * sizeof(int64_t));
/* the algorithm itself (timed) */
bench_start();
pagerank (S, nv, pagerank_scores, pagerank_scores_tmp, 1e-8, 0.85, 100);
bench_end();
printf("Done.\n");
/* cleanup */
free (pagerank_scores);
free (pagerank_scores_tmp);
stinger_free_all (S);
return 0;
}
static string
kpsewhich (string name) {
bench_start ("kpsewhich");
string which= var_eval_system ("kpsewhich " * name);
bench_cumul ("kpsewhich");
return which;
}
void
edit_typeset_rep::typeset_sub (SI& x1, SI& y1, SI& x2, SI& y2) {
//time_t t1= texmacs_time ();
typeset_prepare ();
eb= empty_box (reverse (rp));
// saves memory, also necessary for change_log update
bench_start ("typeset");
#ifdef USE_EXCEPTIONS
try {
#endif
eb= ::typeset (ttt, x1, y1, x2, y2);
#ifdef USE_EXCEPTIONS
}
catch (string msg) {
the_exception= msg;
std_error << "Typesetting failure, resetting to empty document\n";
assign (rp, tree (DOCUMENT, ""));
::notify_assign (ttt, path(), subtree (et, rp));
eb= ::typeset (ttt, x1, y1, x2, y2);
}
handle_exceptions ();
#endif
bench_end ("typeset");
//time_t t2= texmacs_time ();
//if (t2 - t1 >= 10) cout << "typeset took " << t2-t1 << "ms\n";
picture_cache_clean ();
}
// evaluate cost of a simple as possible system call
void bench_syscall(void)
{
uint64_t t0, t1;
int i;
t0 = bench_start();
for (i = 0; i < N; i++) {
syscall(SYS_getpid);
}
t1 = bench_end();
printf("System call (getpid): %" PRIu64 " cycles\n",
(t1 - t0 - tsc_overhead) / N);
}
void bench_sleep(void)
{
printf("\n=> TSC Vs. Clock accuray (need to adjust TSC freq to machine)\n");
printf("Testing `sleep()`");
uint64_t t0, t1;
int i;
t0 = bench_start();
sleep(2);
t1 = bench_start();
printf("TSC : %" PRIu64 " cycles\n", (t1 - t0 - tsc_overhead) / N);
printf("TSC : %" PRIu64 " ns\n", cycles_to_ns((t1 - t0 - tsc_overhead) / N));
t0 = clock_ns();
sleep(2);
t1 = clock_ns();
printf("CLOCK: %" PRIu64 " ns\n", (t1 - t0 - clk_overhead) / N);
printf("\n=> TSC Vs. Clock call-cost\n");
printf("TSC : %" PRIu64 " cycles\n", tsc_overhead);
printf("CLOCK: %" PRIu64 " cycles\n\n", clk_overhead);
}
// measure the cost to call `clock_gettime` for the specified clock
uint64_t clock_overhead()
{
int i;
struct timespec t;
uint64_t t0, t1, overhead = ~0;
// we run N times and take the min
for (i = 0; i < N; i++) {
t0 = bench_start();
clock_gettime(CLOCK, &t);
t1 = bench_end();
if (t1 - t0 < overhead)
overhead = t1 - t0;
}
return overhead - tsc_overhead;
}
void
load_tex (string family, int size, int dpi, int dsize,
tex_font_metric& tfm, font_glyphs& pk)
{
bench_start ("load tex font");
if (DEBUG_VERBOSE)
debug_fonts << "Loading " << family << size
<< " at " << dpi << " dpi\n";
if (load_tex_tfm (family, size, dsize, tfm) &&
load_tex_pk (family, size, dpi, dsize, tfm, pk))
{
bench_cumul ("load tex font");
rubber_fix (tfm, pk);
return;
}
if (DEBUG_VERBOSE) {
debug_fonts << "Font " << family << size
<< " at " << dpi << " dpi not found\n";
debug_fonts << "Loading ecrm" << size
<< " at " << dpi << " dpi instead\n";
}
if (load_tex_tfm ("ecrm", size, 10, tfm) &&
load_tex_pk ("ecrm", size, dpi, 10, tfm, pk))
{
bench_cumul ("load tex font");
return;
}
#ifdef OS_WIN32
else {
string name= family * as_string (size) * "@" * as_string (dpi);
failed_error << "Could not open font " << name << "\nLoading default" << LF;
cout << "Could not load font...\nLoading default" << LF;
XNoTexWarn();
if (load_tex_tfm ("ecrm", 10, 10, tfm) &&
load_tex_pk ("ecrm", 10, 600, 10, tfm, pk))
{
bench_cumul ("load tex font");
return;
}
}
#endif
string name= family * as_string (size) * "@" * as_string (dpi);
failed_error << "Could not open " << name << "\n";
FAILED ("Tex seems not to be installed properly");
bench_cumul ("load tex font");
}
int
test_main (void)
{
json_ctx_t json_ctx;
size_t i;
bench_start ();
json_init (&json_ctx, 2, stdout);
json_attr_object_begin (&json_ctx, TEST_NAME);
/* Create 2 test arrays, one with 10% zeroes, 10% negative values,
79% positive values and 1% infinity/NaN. The other contains
50% inf, 50% NaN. This relies on rand behaving correctly. */
for (i = 0; i < SIZE; i++)
{
int x = rand () & 255;
arr1[i] = (x < 25) ? 0.0 : ((x < 50) ? -1 : 100);
if (x == 255) arr1[i] = __builtin_inf ();
if (x == 254) arr1[i] = __builtin_nan ("0");
arr2[i] = (x < 128) ? __builtin_inf () : __builtin_nan ("0");
}
for (i = 0; i < sizeof (test_list) / sizeof (test_list[0]); i++)
{
json_attr_object_begin (&json_ctx, test_list[i].name);
do_one_test (&json_ctx, test_list[i].fn, arr2, SIZE, "inf/nan");
json_attr_object_end (&json_ctx);
}
for (i = 0; i < sizeof (test_list) / sizeof (test_list[0]); i++)
{
json_attr_object_begin (&json_ctx, test_list[i].name);
do_one_test (&json_ctx, test_list[i].fn, arr1, SIZE, "normal");
json_attr_object_end (&json_ctx);
}
json_attr_object_end (&json_ctx);
return 0;
}
int
main(void)
{
struct xkb_context *ctx;
struct xkb_keymap *keymap;
struct xkb_state *state;
struct bench bench;
char *elapsed;
ctx = test_get_context(0);
assert(ctx);
keymap = test_compile_rules(ctx, "evdev", "pc104", "us,ru,il,de",
",,,neo", "grp:menu_toggle");
assert(keymap);
state = xkb_state_new(keymap);
assert(state);
xkb_context_set_log_level(ctx, XKB_LOG_LEVEL_CRITICAL);
xkb_context_set_log_verbosity(ctx, 0);
srand(time(NULL));
bench_start(&bench);
bench_key_proc(state);
bench_stop(&bench);
elapsed = bench_elapsed_str(&bench);
fprintf(stderr, "ran %d iterations in %ss\n",
BENCHMARK_ITERATIONS, elapsed);
free(elapsed);
xkb_state_unref(state);
xkb_keymap_unref(keymap);
xkb_context_unref(ctx);
return 0;
}
tm_server_rep::tm_server_rep (): def_zoomf (1.0) {
the_server= tm_new<server> (this);
initialize_scheme ();
gui_interpose (texmacs_interpose_handler);
set_wait_handler (texmacs_wait_handler);
if (is_none (tm_init_file))
tm_init_file= "$TEXMACS_PATH/progs/init-texmacs.scm";
if (is_none (my_init_file))
my_init_file= "$TEXMACS_HOME_PATH/progs/my-init-texmacs.scm";
bench_start ("initialize scheme");
if (exists (tm_init_file)) exec_file (tm_init_file);
if (exists (my_init_file)) exec_file (my_init_file);
bench_cumul ("initialize scheme");
if (my_init_cmds != "") {
my_init_cmds= "(begin" * my_init_cmds * ")";
exec_delayed (scheme_cmd (my_init_cmds));
}
#ifdef OS_GNU_LINUX
return; // in order to avoid segmentation faults
#elif defined OS_POWERPC_GNU_LINUX
return; // in order to avoid segmentation faults
#endif
}
int
main (int argc, char** argv) {
boot_hacks ();
windows_delayed_refresh (1000000000);
immediate_options (argc, argv);
set_env ("LC_NUMERIC", "POSIX");
#ifdef MACOSX_EXTENSIONS
// Reset TeXmacs if Alt is pressed during startup
if (mac_alternate_startup()) {
cout << "TeXmacs] Performing setup (Alt on startup)" << LF;
remove (url ("$TEXMACS_HOME_PATH/system/settings.scm"));
remove (url ("$TEXMACS_HOME_PATH/system/setup.scm"));
remove (url ("$TEXMACS_HOME_PATH/system/cache") * url_wildcard ("*"));
remove (url ("$TEXMACS_HOME_PATH/fonts/error") * url_wildcard ("*"));
}
#endif
#ifdef QTTEXMACS
// initialize the Qt application infrastructure
new QTMApplication (argc, argv);
#endif
TeXmacs_init_paths (argc, argv);
//cout << "Bench ] Started TeXmacs\n";
the_et = tuple ();
the_et->obs= ip_observer (path ());
cache_initialize ();
bench_start ("initialize texmacs");
init_texmacs ();
bench_cumul ("initialize texmacs");
#ifdef ENABLE_TESTS
test_routines ();
#endif
//#ifdef EXPERIMENTAL
// test_environments ();
//#endif
start_scheme (argc, argv, TeXmacs_main);
return 0;
}
int
main (int argc, char **argv)
{
unsigned long i, k;
struct timespec runtime;
timing_t start, end;
bool detailed = false;
json_ctx_t json_ctx;
if (argc == 2 && !strcmp (argv[1], "-d"))
detailed = true;
bench_start ();
memset (&runtime, 0, sizeof (runtime));
unsigned long iters, res;
#ifdef BENCH_INIT
BENCH_INIT ();
#endif
TIMING_INIT (res);
iters = 1000 * res;
json_init (&json_ctx, 2, stdout);
/* Begin function. */
json_attr_object_begin (&json_ctx, FUNCNAME);
for (int v = 0; v < NUM_VARIANTS; v++)
{
/* Run for approximately DURATION seconds. */
clock_gettime (CLOCK_MONOTONIC_RAW, &runtime);
runtime.tv_sec += DURATION;
double d_total_i = 0;
timing_t total = 0, max = 0, min = 0x7fffffffffffffff;
int64_t c = 0;
while (1)
{
for (i = 0; i < NUM_SAMPLES (v); i++)
{
uint64_t cur;
TIMING_NOW (start);
for (k = 0; k < iters; k++)
BENCH_FUNC (v, i);
TIMING_NOW (end);
TIMING_DIFF (cur, start, end);
if (cur > max)
max = cur;
if (cur < min)
min = cur;
TIMING_ACCUM (total, cur);
/* Accumulate timings for the value. In the end we will divide
by the total iterations. */
RESULT_ACCUM (cur, v, i, c * iters, (c + 1) * iters);
d_total_i += iters;
}
c++;
struct timespec curtime;
memset (&curtime, 0, sizeof (curtime));
clock_gettime (CLOCK_MONOTONIC_RAW, &curtime);
if (TIMESPEC_AFTER (curtime, runtime))
goto done;
}
double d_total_s;
double d_iters;
done:
d_total_s = total;
d_iters = iters;
/* Begin variant. */
json_attr_object_begin (&json_ctx, VARIANT (v));
json_attr_double (&json_ctx, "duration", d_total_s);
json_attr_double (&json_ctx, "iterations", d_total_i);
json_attr_double (&json_ctx, "max", max / d_iters);
json_attr_double (&json_ctx, "min", min / d_iters);
json_attr_double (&json_ctx, "mean", d_total_s / d_total_i);
if (detailed)
{
json_array_begin (&json_ctx, "timings");
for (int i = 0; i < NUM_SAMPLES (v); i++)
json_element_double (&json_ctx, RESULT (v, i));
json_array_end (&json_ctx);
}
/* End variant. */
json_attr_object_end (&json_ctx);
}
/* End function. */
json_attr_object_end (&json_ctx);
return 0;
}
int main(){
bench_start();
int result = tarai(12,6,0);
bench_end();
}
void
TeXmacs_main (int argc, char** argv) {
int i;
bool flag= true;
string the_default_font;
for (i=1; i<argc; i++)
if (argv[i][0] == '\0') argc= i;
else if (((argv[i][0] == '-') ||
(argv[i][0] == '+')) && (argv[i][1] != '\0'))
{
string s= argv[i];
if ((N(s)>=2) && (s(0,2)=="--")) s= s (1, N(s));
if ((s == "-s") || (s == "-silent")) flag= false;
else if ((s == "-V") || (s == "-verbose"))
debug (DEBUG_FLAG_VERBOSE, true);
else if ((s == "-d") || (s == "-debug")) debug (DEBUG_FLAG_STD, true);
else if (s == "-debug-events") debug (DEBUG_FLAG_EVENTS, true);
else if (s == "-debug-io") debug (DEBUG_FLAG_IO, true);
else if (s == "-debug-bench") debug (DEBUG_FLAG_BENCH, true);
else if (s == "-debug-history") debug (DEBUG_FLAG_HISTORY, true);
else if (s == "-debug-qt") debug (DEBUG_FLAG_QT, true);
else if (s == "-debug-qt-widgets") debug (DEBUG_FLAG_QT_WIDGETS, true);
else if (s == "-debug-keyboard") debug (DEBUG_FLAG_KEYBOARD, true);
else if (s == "-debug-packrat") debug (DEBUG_FLAG_PACKRAT, true);
else if (s == "-debug-flatten") debug (DEBUG_FLAG_FLATTEN, true);
else if (s == "-debug-correct") debug (DEBUG_FLAG_CORRECT, true);
else if (s == "-debug-convert") debug (DEBUG_FLAG_CONVERT, true);
else if (s == "-debug-all") {
debug (DEBUG_FLAG_EVENTS, true);
debug (DEBUG_FLAG_STD, true);
debug (DEBUG_FLAG_IO, true);
debug (DEBUG_FLAG_HISTORY, true);
debug (DEBUG_FLAG_BENCH, true);
debug (DEBUG_FLAG_QT, true);
debug (DEBUG_FLAG_QT_WIDGETS, true);
}
else if (s == "-disable-error-recovery") disable_error_recovery= true;
else if ((s == "-fn") || (s == "-font")) {
i++;
if (i<argc) the_default_font= argv[i];
}
else if ((s == "-g") || (s == "-geometry")) {
i++;
if (i<argc) {
string g= argv[i];
int j=0, j1, j2, j3;
for (j=0; j<N(g); j++)
if (g[j] == 'x') break;
j1=j; if (j<N(g)) j++;
for (; j<N(g); j++)
if ((g[j] == '+') || (g[j] == '-')) break;
j2=j; if (j<N(g)) j++;
for (; j<N(g); j++)
if ((g[j] == '+') || (g[j] == '-')) break;
j3=j;
if (j1<N(g)) {
geometry_w= max (as_int (g (0, j1)), 320);
geometry_h= max (as_int (g (j1+1, j2)), 200);
}
if (j3<N(g)) {
if (g[j2] == '-') geometry_x= as_int (g (j2, j3)) - 1;
else geometry_x= as_int (g (j2+1, j3));
if (g[j3] == '-') geometry_y= as_int (g (j3, N(g))) - 1;
else geometry_y= as_int (g (j3+1, N(g)));
}
}
}
else if ((s == "-b") || (s == "-initialize-buffer")) {
i++;
if (i<argc) tm_init_buffer_file= url_system (argv[i]);
}
else if ((s == "-i") || (s == "-initialize")) {
i++;
if (i<argc) tm_init_file= url_system (argv[i]);
}
else if ((s == "-v") || (s == "-version")) {
cout << "\n";
cout << "TeXmacs version " << TEXMACS_VERSION << "\n";
cout << TEXMACS_COPYRIGHT << "\n";
cout << "\n";
exit (0);
}
else if ((s == "-p") || (s == "-path")) {
cout << get_env ("TEXMACS_PATH") << "\n";
exit (0);
}
else if ((s == "-bp") || (s == "-binpath")) {
cout << get_env ("TEXMACS_BIN_PATH") << "\n";
exit (0);
}
else if ((s == "-q") || (s == "-quit"))
my_init_cmds= my_init_cmds * " (quit-TeXmacs)";
else if ((s == "-r") || (s == "-reverse"))
set_reverse_colors (true);
else if (s == "-no-retina") {
retina_manual= true;
retina_factor= 1;
retina_icons = 1;
retina_scale = 1.0;
}
else if ((s == "-R") || (s == "-retina")) {
retina_manual= true;
retina_factor= 2;
retina_icons = 2;
retina_scale = 1.4;
}
else if (s == "-no-retina-icons") {
retina_iman = true;
retina_icons = 1;
}
else if (s == "-retina-icons") {
retina_iman = true;
retina_icons = 2;
}
else if ((s == "-c") || (s == "-convert")) {
i+=2;
if (i<argc) {
url in ("$PWD", argv[i-1]);
url out ("$PWD", argv[ i ]);
my_init_cmds= my_init_cmds * " " *
"(load-buffer " * scm_quote (as_string (in)) * " :strict) " *
"(export-buffer " * scm_quote (as_string (out)) * ")";
}
}
else if ((s == "-x") || (s == "-execute")) {
i++;
if (i<argc) my_init_cmds= (my_init_cmds * " ") * argv[i];
}
else if (s == "-server") start_server_flag= true;
else if (s == "-log-file") i++;
else if ((s == "-Oc") || (s == "-no-char-clipping")) char_clip= false;
else if ((s == "+Oc") || (s == "-char-clipping")) char_clip= true;
else if ((s == "-S") || (s == "-setup") ||
(s == "-delete-cache") || (s == "-delete-font-cache") ||
(s == "-delete-style-cache") || (s == "-delete-file-cache") ||
(s == "-delete-doc-cache") || (s == "-delete-plugin-cache") ||
(s == "-delete-server-data") || (s == "-delete-databases"));
else if (starts (s, "-psn"));
else {
cout << "\n";
cout << "Options for TeXmacs:\n\n";
cout << " -b [file] Specify scheme buffers initialization file\n";
cout << " -c [i] [o] Convert file 'i' into file 'o'\n";
cout << " -d For debugging purposes\n";
cout << " -fn [font] Set the default TeX font\n";
cout << " -g [geom] Set geometry of window in pixels\n";
cout << " -h Display this help message\n";
cout << " -i [file] Specify scheme initialization file\n";
cout << " -p Get the TeXmacs path\n";
cout << " -q Shortcut for -x \"(quit-TeXmacs)\"\n";
cout << " -r Reverse video mode\n";
cout << " -s Suppress information messages\n";
cout << " -S Rerun TeXmacs setup program before starting\n";
cout << " -v Display current TeXmacs version\n";
cout << " -V Show some informative messages\n";
cout << " -x [cmd] Execute scheme command\n";
cout << " -Oc TeX characters bitmap clipping off\n";
cout << " +Oc TeX characters bitmap clipping on (default)\n";
cout << "\nPlease report bugs to <*****@*****.**>\n";
cout << "\n";
exit (0);
}
}
if (flag) debug (DEBUG_FLAG_AUTO, true);
// Further options via environment variables
if (get_env ("TEXMACS_RETINA") == "off") {
retina_manual= true;
retina_factor= 1;
retina_icons = 1;
retina_scale = 1.0;
}
if (get_env ("TEXMACS_RETINA") == "on") {
retina_manual= true;
retina_factor= 2;
retina_icons = 2;
retina_scale = 1.4;
}
if (get_env ("TEXMACS_RETINA_ICONS") == "off") {
retina_iman = true;
retina_icons = 1;
}
if (get_env ("TEXMACS_RETINA_ICONS") == "on") {
retina_iman = true;
retina_icons = 2;
}
// End options via environment variables
if (DEBUG_STD) debug_boot << "Installing internal plug-ins...\n";
bench_start ("initialize plugins");
init_plugins ();
bench_cumul ("initialize plugins");
if (DEBUG_STD) debug_boot << "Opening display...\n";
#if defined(X11TEXMACS) && defined(MACOSX_EXTENSIONS)
init_mac_application ();
#endif
gui_open (argc, argv);
set_default_font (the_default_font);
if (DEBUG_STD) debug_boot << "Starting server...\n";
{ // opening scope for server sv
server sv;
// HACK:
// Qt and Guile want to change the locale.
// We need to force it to C to parse correctly the configuration files
// (see as_double() in string.cpp)
setlocale(LC_NUMERIC, "C");
string where= "";
for (i=1; i<argc; i++) {
if (argv[i] == NULL) break;
string s= argv[i];
if ((N(s)>=2) && (s(0,2)=="--")) s= s (1, N(s));
if ((s[0] != '-') && (s[0] != '+')) {
if (DEBUG_STD) debug_boot << "Loading " << s << "...\n";
url u= url_system (s);
if (!is_rooted (u)) u= resolve (url_pwd (), "") * u;
string b= scm_quote (as_string (u));
string cmd= "(load-buffer " * b * " " * where * ")";
where= " :new-window";
exec_delayed (scheme_cmd (cmd));
}
if ((s == "-c") || (s == "-convert")) i+=2;
else if ((s == "-b") || (s == "-initialize-buffer") ||
(s == "-fn") || (s == "-font") ||
(s == "-i") || (s == "-initialize") ||
(s == "-g") || (s == "-geometry") ||
(s == "-x") || (s == "-execute") ||
(s == "-log-file")) i++;
}
if (install_status == 1) {
if (DEBUG_STD) debug_boot << "Loading welcome message...\n";
url u= "tmfs://help/plain/tm/doc/about/welcome/first.en.tm";
string b= scm_quote (as_string (u));
string cmd= "(load-buffer " * b * " " * where * ")";
where= " :new-window";
exec_delayed (scheme_cmd (cmd));
}
else if (install_status == 2) {
if (DEBUG_STD) debug_boot << "Loading upgrade message...\n";
url u= "tmfs://help/plain/tm/doc/about/changes/changes-recent.en.tm";
string b= scm_quote (as_string (u));
string cmd= "(load-buffer " * b * " " * where * ")";
where= " :new-window";
exec_delayed (scheme_cmd (cmd));
}
if (number_buffers () == 0) {
if (DEBUG_STD) debug_boot << "Creating 'no name' buffer...\n";
open_window ();
}
bench_print ();
bench_reset ("initialize texmacs");
bench_reset ("initialize plugins");
bench_reset ("initialize scheme");
if (DEBUG_STD) debug_boot << "Starting event loop...\n";
texmacs_started= true;
if (!disable_error_recovery) signal (SIGSEGV, clean_exit_on_segfault);
if (start_server_flag) server_start ();
gui_start_loop ();
if (DEBUG_STD) debug_boot << "Stopping server...\n";
} // ending scope for server sv
if (DEBUG_STD) debug_boot << "Closing display...\n";
gui_close ();
#if defined(X11TEXMACS) && defined(MACOSX_EXTENSIONS)
finalize_mac_application ();
#endif
if (DEBUG_STD) debug_boot << "Good bye...\n";
}
/**
* \defgroup public Kitsune API
*
* Calls to kitsune_update indicate that a possible update point has been
* reached. The argument "pt_name" provides an identifier indicating which
* point was reached.
* @{
*/
void kitsune_update(const char *pt_name)
{
/*
* If we were starting up following an update from a previous version (and so
* the updating flag is set) the fact that we have reached an update point
* indicates that we are done starting up and now resume regular execution.
*/
if (kitsune_is_updating()) {
/*
* If we're starting up following an update, but we're not at the update
* point corresponding to the long-running loop that we need to reach, then
* we just return. This allows reaching intermediate upate points on the
* way to the final point.
*/
if (!kitsune_is_updating_from(pt_name))
return;
/*
* We may wish to perform some initialization (e.g., altering the set of
* threads) after we reach the main thread's update point, but before any
* child threads are created.
*/
#ifdef ENABLE_THREADING
if (ktthread_is_main()) {
#endif
state_xform_fn_t mu_fn = kitsune_get_cur_val("_kitsune_mainupdate_xform");
if (mu_fn) {
kitsune_log("Calling main-update transformation function.");
mu_fn();
}
#ifdef ENABLE_THREADING
}
#endif
#ifdef ENABLE_THREADING
if (ktthread_is_main()) {
/* Now that we've reached the main loop of the main thread, we can kick
off execution of the child threads and then wait until they reach their
main loops (or die) */
ktthread_launch_wait();
#endif
/*
* Free any memory used to store the old versions stack variables (those
* managed through the stackvars API).
*/
kitsune_log("before freeing....");
bench_log_resource_usage();
stackvars_free();
registervars_free();
addresscheck_free();
/*
* Since we're done accessing values from the previous version, we now close
* our handle to its shared library which makes its state inaccessible and
* unloads its code.
*/
if (dlclose(prev_ver_handle)) {
kitsune_log("dlclose: error occurred: (%s)\n", dlerror());
exit(1);
}
prev_ver_handle = NULL;
transform_free();
bench_finish();
kitsune_log("teardown complete....");
bench_log_resource_usage();
#ifdef ENABLE_THREADING
/* Signal threads to continue running */
ktthread_main_finish_update();
} else {
stackvars_free();
ktthread_finish_update();
}
#endif
}
/*
* Check whether an update is available.
*/
if (update_requested) {
kitsune_log("Updating(%s)...\n", pt_name);
bench_log_resource_usage();
bench_start();
/*
* Move current stack variables (managed through the stackvars API) from the
* stack to the heap.
*/
stackvars_move_to_heap();
#ifdef ENABLE_THREADING
ktthread_rapidq();
if (ktthread_is_main()) {
#endif
/*
* To update, we store the current update point taken to make it available
* to the next version
*/
update_pt = pt_name;
/*
* And then longjmp back to the driver code.
*/
assert(jmp_env != NULL);
longjmp(*jmp_env, 1);
#ifdef ENABLE_THREADING
} else {
ktthread_do_update(pt_name);
}
#endif
}
}
int main(int argc, char **argv) {
config_init();
int c;
while (-1 != (c = getopt(argc, argv, "n:m:k:d:p:h"))) {
switch(c) {
case 'n':
config.num = atoi(optarg);
break;
case 'm':
config.maxbytes = ((size_t)atoi(optarg)) * 1024 * 1024;
break;
case 'k':
config.keysize = atoi(optarg);
break;
case 'd':
config.datasize = atoi(optarg);
break;
case 'p':
config.hashpower = atoi(optarg);
break;
case 'h':
usage();
return EXIT_SUCCESS;
default:
usage();
return EXIT_FAILURE;
}
}
generate_key_init();
print_env();
lru *l = lru_init(config.maxbytes, config.hashpower);
char *bvalue = malloc(config.datasize);
memset(bvalue, 'x', config.datasize);
char *key = malloc(config.keysize);
memset(key, 0, config.keysize);
int gnum = config.keysize - num_;
generate_key_reset();
bench_start("SET");
int i;
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
int r = item_set(l, key, config.keysize, bvalue, config.datasize);
assert(r == 0);
process_report();
}
bench_stop();
print_stat(l);
char *buf = malloc(config.datasize);
size_t sz;
generate_key_reset();
bench_start("GET");
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
int r = item_get(l, key, config.keysize, buf, config.datasize, &sz);
if (!r) {
assert((int)sz == config.datasize);
assert(memcmp(bvalue, buf, config.datasize) == 0);
}
memset(buf, 0, config.datasize);
process_report();
}
bench_stop();
print_stat(l);
generate_key_reset();
bench_start("DELETE");
for (i = 0; i < config.num; i++) {
snprintf(key, config.keysize, fmt_, gnum, generate_key(gnum), i);
item_delete(l, key, config.keysize);
process_report();
}
bench_stop();
print_stat(l);
free(buf);
free(bvalue);
free(key);
free(fmt_);
free(key_);
lru_free(l);
/*
printf("print any key to exit...\n");
getchar();
*/
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
int rv;
unsigned int ret;
USBContext context;
USBBuffer buffer(65);
//context.setDebug(4);
USBDevice::Ptr device = context.openDeviceWithVidPid(0x04b4, 0x1004);
#ifndef WIN32
if(device->isKernelDriverActive(0)) device->detachKernelDriver(0);
#endif
device->setConfiguration(1);
device->claimInterface(0);
device->setInterfaceAltSetting(0, 0);
libusb_device_handle *hndl = device->getDeviceHandle();
while(read_debug(hndl) != LIBUSB_ERROR_TIMEOUT);
printf("AdslSniffer Test\n");
printf("RESET\n");
rv = libusb_control_transfer(hndl,
LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
0x90,
0x11,
0x22,
0,
0,
0);
if(rv != 0) {
printf ( "CONTROL Transfer failed: %s(%d)\n", libusb_error_name(rv), rv);
return rv;
}
ret = buffer.controlTransfer(*device, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, 0x94, 0x11, 0x22, buffer.getBufferSize()-1);
if(ret < buffer.getBufferSize()) {
unsigned char *cBuffer = buffer.getBuffer();
cBuffer[ret] = '\0';
std::cout << cBuffer << std::endl;
} else {
std::cerr << "Error during version grabbing" << std::endl;
}
ret = buffer.controlTransfer(*device, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, 0x95, 0x11, 0x22, buffer.getBufferSize()-1);
if(ret == 4) {
unsigned int *rate = (unsigned int *)buffer.getBuffer();
std::cout << "Sample rate: " << *rate << std::endl;
} else {
std::cerr << "Error during sample rate grabbing" << std::endl;
}
printf("Enable debug\n");
rv = libusb_control_transfer(hndl,
LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
0x91,
0x01,
0x22,
0,
0,
0);
if(rv != 0) {
printf ( "CONTROL(Debug) Transfer failed: %s(%d)\n", libusb_error_name(rv), rv);
return rv;
}
read_debug(hndl, 1000);
while(read_debug(hndl) != LIBUSB_ERROR_TIMEOUT);
printf("Print test\n");
rv = libusb_control_transfer(hndl,
LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
0x99,
0x00,
0x22,
0,
0,
0);
if(rv != 0) {
printf ( "CONTROL(Debug) Transfer failed: %s(%d)\n", libusb_error_name(rv), rv);
return rv;
}
read_debug(hndl, 1000);
while(read_debug(hndl) != LIBUSB_ERROR_TIMEOUT);
printf("Start Test\n");
rv = libusb_control_transfer(hndl,
LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
0x92,
0xffff,
0xffff,
0,
0,
0);
if(rv != 0) {
printf ( "CONTROL(Start) Transfer failed: %s(%d)\n", libusb_error_name(rv), rv);
return rv;
}
read_debug(hndl, 0);
while(read_debug(hndl) != LIBUSB_ERROR_TIMEOUT);
USBRequest request(8, 2048);
context.start<>();
// Send request
bench_start();
request.send(device, 0x82, BENCH_DATA_SIZE, usb_cb);
bench_inc();
request.wait();
bench_stop();
context.stop();
context.wait();
printf("Stop Test\n");
rv = libusb_control_transfer(hndl,
LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
0x93,
0xffff,
0xffff,
0,
0,
0);
if(rv != 0) {
printf ( "CONTROL(Stop) Transfer failed: %s(%d)\n", libusb_error_name(rv), rv);
return rv;
}
read_debug(hndl, 0);
while(read_debug(hndl) != LIBUSB_ERROR_TIMEOUT);
printf("Print test\n");
rv = libusb_control_transfer(hndl,
LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
0x99,
0x00,
0x22,
0,
0,
0);
if(rv != 0) {
printf ( "CONTROL(Debug) Transfer failed: %s(%d)\n", libusb_error_name(rv), rv);
return rv;
}
read_debug(hndl, 0);
while(read_debug(hndl) != LIBUSB_ERROR_TIMEOUT);
// Empty debug
while(read_debug(hndl) != LIBUSB_ERROR_TIMEOUT);
// Close device
device->releaseInterface(0);
device.reset();
printf("Test end\n");
bench_stats();
return 0;
}
static double
bench(const LilvPlugin* p, uint32_t sample_count, uint32_t block_size)
{
URITable uri_table;
uri_table_init(&uri_table);
LV2_URID_Map map = { &uri_table, uri_table_map };
LV2_Feature map_feature = { LV2_URID_MAP_URI, &map };
LV2_URID_Unmap unmap = { &uri_table, uri_table_unmap };
LV2_Feature unmap_feature = { LV2_URID_UNMAP_URI, &unmap };
const LV2_Feature* features[] = { &map_feature, &unmap_feature, NULL };
float* const buf = (float*)calloc(block_size * 2, sizeof(float));
float* const in = buf;
float* const out = buf + block_size;
if (!buf) {
fprintf(stderr, "Out of memory\n");
return 0.0;
}
LV2_Atom_Sequence seq = {
{ sizeof(LV2_Atom_Sequence_Body),
uri_table_map(&uri_table, LV2_ATOM__Sequence) },
{ 0, 0 } };
const char* uri = lilv_node_as_string(lilv_plugin_get_uri(p));
LilvNodes* required = lilv_plugin_get_required_features(p);
LILV_FOREACH(nodes, i, required) {
const LilvNode* feature = lilv_nodes_get(required, i);
if (!lilv_node_equals(feature, urid_map)) {
fprintf(stderr, "<%s> requires feature <%s>, skipping\n",
uri, lilv_node_as_uri(feature));
free(buf);
uri_table_destroy(&uri_table);
return 0.0;
}
}
LilvInstance* instance = lilv_plugin_instantiate(p, 48000.0, features);
if (!instance) {
fprintf(stderr, "Failed to instantiate <%s>\n",
lilv_node_as_uri(lilv_plugin_get_uri(p)));
free(buf);
uri_table_destroy(&uri_table);
return 0.0;
}
float* controls = (float*)calloc(
lilv_plugin_get_num_ports(p), sizeof(float));
lilv_plugin_get_port_ranges_float(p, NULL, NULL, controls);
const uint32_t n_ports = lilv_plugin_get_num_ports(p);
for (uint32_t index = 0; index < n_ports; ++index) {
const LilvPort* port = lilv_plugin_get_port_by_index(p, index);
if (lilv_port_is_a(p, port, lv2_ControlPort)) {
lilv_instance_connect_port(instance, index, &controls[index]);
} else if (lilv_port_is_a(p, port, lv2_AudioPort) ||
lilv_port_is_a(p, port, lv2_CVPort)) {
if (lilv_port_is_a(p, port, lv2_InputPort)) {
lilv_instance_connect_port(instance, index, in);
} else if (lilv_port_is_a(p, port, lv2_OutputPort)) {
lilv_instance_connect_port(instance, index, out);
} else {
fprintf(stderr, "<%s> port %d neither input nor output, skipping\n",
uri, index);
lilv_instance_free(instance);
free(buf);
free(controls);
uri_table_destroy(&uri_table);
return 0.0;
}
} else if (lilv_port_is_a(p, port, atom_AtomPort)) {
lilv_instance_connect_port(instance, index, &seq);
} else {
fprintf(stderr, "<%s> port %d has unknown type, skipping\n",
uri, index);
lilv_instance_free(instance);
free(buf);
free(controls);
uri_table_destroy(&uri_table);
return 0.0;
}
}
lilv_instance_activate(instance);
struct timespec ts = bench_start();
for (uint32_t i = 0; i < (sample_count / block_size); ++i) {
lilv_instance_run(instance, block_size);
}
const double elapsed = bench_end(&ts);
lilv_instance_deactivate(instance);
lilv_instance_free(instance);
uri_table_destroy(&uri_table);
if (full_output) {
printf("%d %d ", block_size, sample_count);
}
printf("%lf %s\n", elapsed, uri);
free(buf);
free(controls);
return elapsed;
}
