--- /dev/null
+/*
+** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
+**
+** This file is part of TACK.
+**
+** TACK is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2, or (at your option)
+** any later version.
+**
+** TACK is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with TACK; see the file COPYING. If not, write to
+** the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+** Boston, MA 02111-1307, USA.
+*/
+
+#include <tack.h>
+#include <time.h>
+
+MODULE_ID("$Id: sync.c,v 1.1 1998/01/10 00:31:07 tom Exp $")
+
+/* terminal-synchronization and performance tests */
+
+static void sync_home(struct test_list *, int *, int *);
+static void sync_lines(struct test_list *, int *, int *);
+static void sync_clear(struct test_list *, int *, int *);
+static void sync_summary(struct test_list *, int *, int *);
+
+struct test_list sync_test_list[] = {
+ {MENU_NEXT, 0, 0, 0, "b) baud rate test", sync_home, 0},
+ {MENU_NEXT, 0, 0, 0, "l) scroll performance", sync_lines, 0},
+ {MENU_NEXT, 0, 0, 0, "c) clear screen performance", sync_clear, 0},
+ {MENU_NEXT, 0, 0, 0, "p) summary of results", sync_summary, 0},
+ {0, 0, 0, 0, txt_longer_test_time, longer_test_time, 0},
+ {0, 0, 0, 0, txt_shorter_test_time, shorter_test_time, 0},
+ {MENU_LAST, 0, 0, 0, 0, 0, 0}
+};
+
+struct test_menu sync_menu = {
+ 0, 'n', 0,
+ "Performance tests", "perf", "n) run standard tests",
+ sync_test, sync_test_list, 0, 0, 0
+};
+
+int tty_can_sync; /* TRUE if tty_sync_error() returned FALSE */
+int tty_newline_rate; /* The number of newlines per second */
+int tty_clear_rate; /* The number of clear-screens per second */
+int tty_cps; /* The number of characters per second */
+
+#define TTY_ACK_SIZE 64
+
+int ACK_terminator; /* terminating ACK character */
+int ACK_length; /* length of ACK string */
+const char *tty_ENQ; /* enquire string */
+char tty_ACK[TTY_ACK_SIZE]; /* ACK response, set by tty_sync_error() */
+
+/*****************************************************************************
+ *
+ * Terminal synchronization.
+ *
+ * These functions handle the messy business of enq-ack handshaking
+ * for timing purposes.
+ *
+ *****************************************************************************/
+
+int
+tty_sync_error(void)
+{
+ int ch, trouble, ack;
+
+ trouble = FALSE;
+ for (;;) {
+ tt_putp(tty_ENQ); /* send ENQ */
+ ch = getnext(STRIP_PARITY);
+ event_start(TIME_SYNC); /* start the timer */
+
+ /*
+ The timer doesn't start until we get the first character.
+ After that I expect to get the remaining characters of
+ the acknowledge string in a short period of time. If
+ that is not true then these characters are coming from
+ the user and we need to send the ENQ sequence out again.
+ */
+ for (ack = 0; ; ) {
+ if (ack < TTY_ACK_SIZE - 2) {
+ tty_ACK[ack] = ch;
+ tty_ACK[ack + 1] = '\0';
+ }
+ if (ch == ACK_terminator) {
+ return trouble;
+ }
+ if (++ack >= ACK_length) {
+ return trouble;
+ }
+ ch = getnext(STRIP_PARITY);
+ if (event_time(TIME_SYNC) > 400000) {
+ break;
+ }
+ }
+
+ set_attr(0); /* just in case */
+ put_crlf();
+ if (trouble) {
+ /* The terminal won't sync. Life is not good. */
+ return TRUE;
+ }
+ put_str(" -- sync -- ");
+ trouble = TRUE;
+ }
+}
+
+/*
+** flush_input()
+**
+** Throw away any output.
+*/
+void
+flush_input(void)
+{
+ if (tty_can_sync == SYNC_TESTED && ACK_terminator >= 0) {
+ (void) tty_sync_error();
+ } else {
+ spin_flush();
+ }
+}
+
+/*
+** probe_enq_ok()
+**
+** does the terminal do enq/ack handshaking?
+*/
+static void
+probe_enq_ok(void)
+{
+ int tc, len, ulen;
+
+ put_str("Testing ENQ/ACK, standby...");
+ fflush(stdout);
+ can_test("u8 u9", FLAG_TESTED);
+
+ tty_ENQ = user9 ? user9 : "\005";
+ tc_putp(tty_ENQ);
+ event_start(TIME_SYNC); /* start the timer */
+ read_key(tty_ACK, TTY_ACK_SIZE - 1);
+
+ if (event_time(TIME_SYNC) > 400000 || tty_ACK[0] == '\0') {
+ /* These characters came from the user. Sigh. */
+ tty_can_sync = SYNC_FAILED;
+ ptext("\nThis program expects the ENQ sequence to be");
+ ptext(" answered with the ACK character. This will help");
+ ptext(" the program reestablish synchronization when");
+ ptextln(" the terminal is overrun with data.");
+ ptext("\nENQ sequence from (u9): ");
+ putln(expand(tty_ENQ));
+ ptext("ACK recieved: ");
+ putln(expand(tty_ACK));
+ len = user8 ? strlen(user8) : 0;
+ sprintf(temp, "Length of ACK %d. Expected length of ACK %d.",
+ (int) strlen(tty_ACK), len);
+ ptextln(temp);
+ if (len) {
+ temp[0] = user8[len - 1];
+ temp[1] = '\0';
+ ptext("Terminating character found in (u8): ");
+ putln(expand(temp));
+ }
+ return;
+ }
+
+ tty_can_sync = SYNC_TESTED;
+ if ((len = strlen(tty_ACK)) == 1) {
+ /* single character acknowledge string */
+ ACK_terminator = tty_ACK[0];
+ ACK_length = 4096;
+ return;
+ }
+ tc = tty_ACK[len - 1];
+ if (user8) {
+ ulen = strlen(user8);
+ if (tc == user8[ulen - 1]) {
+ /* ANSI style acknowledge string */
+ ACK_terminator = tc;
+ ACK_length = 4096;
+ return;
+ }
+ }
+ /* fixed length acknowledge string */
+ ACK_length = len;
+ ACK_terminator = -2;
+}
+
+/*
+** verify_time()
+**
+** verify that the time tests are ready to run.
+** If the baud rate is not set then compute it.
+*/
+void
+verify_time(void)
+{
+ int status, ch;
+
+ if (tty_can_sync == SYNC_FAILED) {
+ return;
+ }
+ probe_enq_ok();
+ put_crlf();
+ if (tty_can_sync == SYNC_TESTED) {
+ put_crlf();
+ if (ACK_terminator >= 0) {
+ ptext("ACK terminating character: ");
+ temp[0] = ACK_terminator;
+ temp[1] = '\0';
+ ptextln(expand(temp));
+ } else {
+ sprintf(temp, "Fixed length ACK, %d characters",
+ ACK_length);
+ ptextln(temp);
+ }
+ }
+ if (tty_baud_rate == 0) {
+ sync_home(&sync_test_list[0], &status, &ch);
+ }
+}
+
+/*****************************************************************************
+ *
+ * Terminal performance tests
+ *
+ * Find out how fast the terminal can:
+ * 1) accept characters
+ * 2) scroll the screen
+ * 3) clear the screen
+ *
+ *****************************************************************************/
+
+/*
+** sync_home(test_list, status, ch)
+**
+** Baudrate test
+*/
+void
+sync_home(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ int j, k;
+ unsigned long rate;
+
+ if (!cursor_home && !cursor_address && !row_address) {
+ ptext("Terminal can not home cursor. ");
+ generic_done_message(t, state, ch);
+ return;
+ }
+ if (skip_pad_test(t, state, ch,
+ "(home) Start baudrate search")) {
+ return;
+ }
+ pad_test_startup(1);
+ do {
+ go_home();
+ for (j = 1; j < lines; j++) {
+ for (k = 0; k < columns; k++) {
+ if (k & 0xF) {
+ put_this(letter);
+ } else {
+ put_this('.');
+ }
+ }
+ SLOW_TERMINAL_EXIT;
+ }
+ NEXT_LETTER;
+ } while(still_testing());
+ pad_test_shutdown(t, auto_right_margin == 0);
+ /* note: tty_frame_size is the real framesize times two.
+ This takes care of half bits. */
+ rate = (tx_cps * tty_frame_size) >> 1;
+ if (rate > tty_baud_rate) {
+ tty_baud_rate = rate;
+ }
+ if (tx_cps > tty_cps) {
+ tty_cps = tx_cps;
+ }
+ sprintf(temp, "%d characters per second. Baudrate %d ", tx_cps, j);
+ ptext(temp);
+ generic_done_message(t, state, ch);
+}
+
+/*
+** sync_lines(test_list, status, ch)
+**
+** How many newlines/second?
+*/
+static void
+sync_lines(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ int j;
+
+ if (skip_pad_test(t, state, ch,
+ "(nel) Start scroll performance test")) {
+ return;
+ }
+ pad_test_startup(0);
+ repeats = 100;
+ do {
+ sprintf(temp, "%d", test_complete);
+ put_str(temp);
+ put_newlines(repeats);
+ } while(still_testing());
+ pad_test_shutdown(t, 0);
+ j = sliding_scale(tx_count[0], 1000000, usec_run_time);
+ if (j > tty_newline_rate) {
+ tty_newline_rate = j;
+ }
+ sprintf(temp, "%d linefeeds per second. ", j);
+ ptext(temp);
+ generic_done_message(t, state, ch);
+}
+
+/*
+** sync_clear(test_list, status, ch)
+**
+** How many clear-screens/second?
+*/
+static void
+sync_clear(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ int j;
+
+ if (!clear_screen) {
+ ptext("Terminal can not clear-screen. ");
+ generic_done_message(t, state, ch);
+ return;
+ }
+ if (skip_pad_test(t, state, ch,
+ "(clear) Start clear-screen performance test")) {
+ return;
+ }
+ pad_test_startup(0);
+ repeats = 20;
+ do {
+ sprintf(temp, "%d", test_complete);
+ put_str(temp);
+ for (j = 0; j < repeats; j++) {
+ put_clear();
+ }
+ } while(still_testing());
+ pad_test_shutdown(t, 0);
+ j = sliding_scale(tx_count[0], 1000000, usec_run_time);
+ if (j > tty_clear_rate) {
+ tty_clear_rate = j;
+ }
+ sprintf(temp, "%d clear-screens per second. ", j);
+ ptext(temp);
+ generic_done_message(t, state, ch);
+}
+
+/*
+** sync_symmary(test_list, status, ch)
+**
+** Print out the test results.
+*/
+static void
+sync_summary(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ char size[32];
+
+ put_crlf();
+ ptextln("Terminal size characters/sec linefeeds/sec clears/sec");
+ sprintf(size, "%dx%d", columns, lines);
+ sprintf(temp, "%-10s%-11s%11d %11d %11d", tty_basename, size,
+ tty_cps, tty_newline_rate, tty_clear_rate);
+ ptextln(temp);
+ generic_done_message(t, state, ch);
+}
+
+/*
+** sync_test(menu)
+**
+** Run at the beginning of the pad tests and function key tests
+*/
+void
+sync_test(
+ struct test_menu *menu)
+{
+ control_init();
+ if (tty_can_sync == SYNC_NOT_TESTED) {
+ verify_time();
+ }
+ if (menu->menu_title) {
+ put_crlf();
+ ptextln(menu->menu_title);
+ }
+}
+
+/*
+** sync_handshake(test_list, status, ch)
+**
+** Test or retest the ENQ/ACK handshake
+*/
+void
+sync_handshake(
+ struct test_list *t GCC_UNUSED,
+ int *state GCC_UNUSED,
+ int *ch GCC_UNUSED)
+{
+ tty_can_sync = SYNC_NOT_TESTED;
+ verify_time();
+}
projects / ncurses.git / blobdiff