Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 223 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/hw/dmx/dmxstat.c b/nx-X11/programs/Xserver/hw/dmx/dmxstat.c
new file mode 100644
index 000000000..3b092b2a8
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/dmx/dmxstat.c
@@ -0,0 +1,223 @@
+/* $XFree86$ */
+/*
+ * Copyright 2002, 2003 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ */
+
+/** \file
+ *
+ * The DMX server code is written to call #dmxSync() whenever an XSync()
+ * might be necessary.  However, since XSync() requires a two way
+ * communication with the other X server, eliminating unnecessary
+ * XSync() calls is a key performance optimization.  Support for this
+ * optimization is provided in #dmxsync.c.  This file provides routines
+ * that evaluate this optimization by counting the number of XSync()
+ * calls and monitoring their latency.  This functionality can be turned
+ * on using the -stat command-line parameter. */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#include "dmx.h"
+#include "dmxstat.h"
+#include "dmxlog.h"
+#include <X11/Xos.h>                /* For sys/time.h */
+
+/** Used to compute a running average of value. */
+typedef struct _DMXStatAvg {
+    int           pos;
+    int           count;
+    unsigned long value[DMX_STAT_LENGTH];
+} DMXStatAvg;
+
+/** Statistical information about XSync calls. */
+struct _DMXStatInfo {
+    unsigned long syncCount;
+    unsigned long oldSyncCount;
+
+    DMXStatAvg    usec;
+    DMXStatAvg    pending;
+
+    unsigned long bins[DMX_STAT_BINS];
+};
+
+/* Interval in mS between statistic message log entries. */
+       int        dmxStatInterval;
+static int        dmxStatDisplays;
+static OsTimerPtr dmxStatTimer;
+
+/** Return the number of microseconds as an unsigned long.
+ * Unfortunately, this is only useful for intervals < about 4 sec.  */
+static unsigned long usec(struct timeval *stop, struct timeval *start)
+{
+    return (stop->tv_sec - start->tv_sec) * 1000000
+        + stop->tv_usec - start->tv_usec;
+}
+
+static unsigned long avg(DMXStatAvg *data, unsigned long *max)
+{
+    unsigned long sum;
+    int           i;
+
+    *max = 0;
+    if (!data->count) return 0;
+
+    for (i = 0, sum = 0; i < data->count; i++) {
+        if (data->value[i] > *max) *max = data->value[i];
+        sum += data->value[i];
+    }
+    return sum / data->count;
+}
+
+/** Turn on XSync statistic gathering and printing.  Print every \a
+ * interval seconds, with lines for the first \a displays.  If \a
+ * interval is NULL, 1 will be used.  If \a displays is NULL, 0 will be
+ * used (meaning a line for every display will be printed).  Note that
+ * this function takes string arguments because it will usually be
+ * called from #ddxProcessArgument in #dmxinit.c. */
+void dmxStatActivate(const char *interval, const char *displays)
+{
+    dmxStatInterval = (interval ? atoi(interval) : 1) * 1000;
+    dmxStatDisplays = (displays ? atoi(displays) : 0);
+
+    if (dmxStatInterval < 1000) dmxStatInterval = 1000;
+    if (dmxStatDisplays < 0)    dmxStatDisplays = 0;
+}
+
+/** Allocate a \a DMXStatInfo structure. */
+DMXStatInfo *dmxStatAlloc(void)
+{
+    DMXStatInfo *pt = malloc(sizeof(*pt));
+    memset(pt, 0, sizeof(*pt));
+    return pt;
+}
+
+/** Free the memory used by a \a DMXStatInfo structure. */
+void dmxStatFree(DMXStatInfo *pt)
+{
+    if (pt) free(pt);
+}
+
+static void dmxStatValue(DMXStatAvg *data, unsigned long value)
+{
+    if (data->count != DMX_STAT_LENGTH) ++data->count;
+    if (data->pos >= DMX_STAT_LENGTH-1) data->pos = 0;
+    data->value[data->pos++] = value;
+}
+
+/** Note that a XSync() was just done on \a dmxScreen with the \a start
+ * and \a stop times (from gettimeofday()) and the number of
+ * pending-but-not-yet-processed XSync requests.  This routine is called
+ * from #dmxDoSync in #dmxsync.c */
+void dmxStatSync(DMXScreenInfo *dmxScreen,
+                 struct timeval *stop, struct timeval *start,
+                 unsigned long pending)
+{
+    DMXStatInfo   *s      = dmxScreen->stat;
+    unsigned long elapsed = usec(stop, start);
+    unsigned long thresh;
+    int           i;
+
+    ++s->syncCount;
+    dmxStatValue(&s->usec, elapsed);
+    dmxStatValue(&s->pending, pending);
+    
+    for (i = 0, thresh = DMX_STAT_BIN0; i < DMX_STAT_BINS-1; i++) {
+        if (elapsed < thresh) {
+            ++s->bins[i];
+            break;
+        }
+        thresh *= DMX_STAT_BINMULT;
+    }
+    if (i == DMX_STAT_BINS-1) ++s->bins[i];
+}
+
+/* Actually do the work of printing out the human-readable message. */
+static CARD32 dmxStatCallback(OsTimerPtr timer, CARD32 t, pointer arg)
+{
+    int         i, j;
+    static int  header = 0;
+    int         limit = dmxNumScreens;
+
+    if (!dmxNumScreens) {
+        header = 0;
+        return DMX_STAT_INTERVAL;
+    }
+
+    if (!header++ || !(header % 10)) {
+        dmxLog(dmxDebug,
+               " S SyncCount  Sync/s avSync mxSync avPend mxPend | "
+               "<10ms   <1s   >1s\n");
+    }
+
+    if (dmxStatDisplays && dmxStatDisplays < limit) limit = dmxStatDisplays;
+    for (i = 0; i < limit; i++) {
+        DMXScreenInfo *dmxScreen = &dmxScreens[i];
+        DMXStatInfo   *s         = dmxScreen->stat;
+        unsigned long aSync, mSync;
+        unsigned long aPend, mPend;
+        
+        if (!s) continue;
+
+        aSync = avg(&s->usec,    &mSync);
+        aPend = avg(&s->pending, &mPend);
+        dmxLog(dmxDebug, "%2d %9lu %7lu %6lu %6lu %6lu %6lu |",
+               i,                                               /* S */
+               s->syncCount,                                    /* SyncCount */
+               (s->syncCount
+                - s->oldSyncCount) * 1000 / dmxStatInterval,    /* Sync/s */
+               aSync,                                           /* us/Sync */
+               mSync,                                           /* max/Sync */
+               aPend,                                           /* avgPend */
+               mPend);                                          /* maxPend */
+        for (j = 0; j < DMX_STAT_BINS; j++)
+            dmxLogCont(dmxDebug, " %5lu", s->bins[j]);
+        dmxLogCont(dmxDebug, "\n");
+
+                                /* Reset/clear */
+        s->oldSyncCount = s->syncCount;
+        for (j = 0; j < DMX_STAT_BINS; j++) s->bins[j] = 0;
+    }
+    return DMX_STAT_INTERVAL;   /* Place on queue again */
+}
+
+/** Try to initialize the statistic gathering and printing routines.
+ * Initialization only takes place if #dmxStatActivate has already been
+ * called.  We don't need the same generation protection that we used in
+ * dmxSyncInit because our timer is always on a queue -- hence, server
+ * generation will always free it. */
+void dmxStatInit(void)
+{
+    if (dmxStatInterval)
+        dmxStatTimer = TimerSet(NULL, 0,
+                                dmxStatInterval, dmxStatCallback, NULL);
+}