Conference bulova::decw_jan-89_to_nov-90

Are you reading events?  I'll bet that something you are doing is creating
events and you are ignoring them.  Plus that is a heck of a lot of requests.
Do you think that is right?

Burns

>Are you reading events?  I'll bet that something you are doing is creating
>events and you are ignoring them.  Plus that is a heck of a lot of requests.

    I'm trying to write a little animation program.  It does
    XPutImage as fast as it can.  I don't know if it will be
    client compute bound or server bound, but clearly something
    along the pipe will get saturated.

    I put a check in for stange events, and there were none.
    Maybe I don't have all events enabled  or some such ???

    Is there a mechanism for flow control?

    -Jeff Bell

    Can you post the code, or a pointer to it?

Below is the X related portion of the code.

I've taken out the graphics generation stuff.
(i.e. it won't compile)

code follows


#include "decw$include:Xlib.h"
#include "decw$include:Xutil.h"

Display *mydisplay;
Window mywindow;
GC mygc;
XImage * myimage;
Drawable mydrawable;

XEvent myevent;
KeySym mykey;

XSizeHints myhint;
int myscreen;
unsigned long myforeground, mybackground;
int i;
int done;
int sync_cnt;
char text[16];
char mybitmap[256][32];
int sky[256];

....
left out the graphics generation

....

/*************** window stuff starts here *************/
win_start(argc,argv)
     int argc;
     char **argv;
{
  mydisplay = XOpenDisplay("");
  myscreen = DefaultScreen(mydisplay);
  mybackground = WhitePixel(mydisplay, myscreen);
  myforeground = BlackPixel(mydisplay, myscreen);  
  myhint.x = 200;myhint.y = 50;
  myhint.width = 256; myhint.height = 256;
  myhint.flags = PPosition | PSize;  

  mywindow = XCreateSimpleWindow (mydisplay,DefaultRootWindow (mydisplay),
				  myhint.x,myhint.y,myhint.width,myhint.height,
				  5, myforeground, mybackground);
  XSetStandardProperties (mydisplay, mywindow, "fract", "fract",
			  None, argv, argc, &myhint);
  mygc = XCreateGC (mydisplay, mywindow, 0, 0);
  XSetBackground (mydisplay, mygc, mybackground);
  XSetForeground (mydisplay, mygc, myforeground);
  XSelectInput (mydisplay, mywindow,
		ButtonPressMask | KeyPressMask | ExposureMask);
  XMapRaised (mydisplay, mywindow);
  myimage = XCreateImage(mydisplay, DefaultVisual(mydisplay,myscreen),
			 1,XYBitmap,0,mybitmap,256,256,32,32);
}

win_stop() {
  XFreeGC (mydisplay, mygc);
  XDestroyWindow (mydisplay,mywindow);
  XCloseDisplay (mydisplay);
}

win_clear_image()
{
  char* data;
  int a;

  data = (char *) mybitmap;
  for (a=0;a<(256*32);a++)
    data[a]=0;
}

win_process_event(){
  XNextEvent(mydisplay, &myevent);
  switch (myevent.type) {
  case Expose:
    if (myevent.xexpose.count == 0) {
      XPutImage ( mydisplay, mywindow , mygc, myimage, 0,0, 0,0 ,256,256) ;
    }
    break;

  case MappingNotify:
    XRefreshKeyboardMapping (&myevent);
    break;
    
  case KeyPress:
    i = XLookupString (&myevent, text, 10, &mykey, 0);
    if (i== 1 && text[0] == 'q') done=1;
    break;

  default:
    /*    printf("got an enexpected event\n"); */
    break;

  }
}

/********** end of xwindow stuff ***********/

/********** main starts here ****************/
main (argc,argv)
     int argc;
     char **argv;
{
  setup_world();

  win_start(argc,argv);  
  XNextEvent (mydisplay, &myevent);

  done = 0;
  while(done == 0) {

    win_clear_image();

    draw_view();     <----  This does XPutPixel calls.

    XPutImage ( mydisplay, mywindow , mygc, myimage, 0,0, 0,0 ,256,256);

    while(XEventsQueued(mydisplay,QueuedAfterReading))
      win_process_event();
  }
  win_stop();
  exit(0);
}

You might try slowing it down with a lib$wait and see if you aren't 
just overpowering the server and overflowing its queue.  An 8800 
against a uvII is pretty uneven.

Bruce

>You might try slowing it down with a lib$wait and see if you aren't 
>just overpowering the server and overflowing its queue.  An 8800 
>against a uvII is pretty uneven.

It is not possible for an 8800 or even a 9000 to "overpower" a server.
The server will take requests from the connection as fast as it can.
If it can't keep up, the buffers will fill up, and the application
will block.  The problem usually comes when the server sends back
events, and the application doesn't keep up with reading them.  If
the buffers from the server to the client fill up, then the server
aborts the connection, and the application dies.

If the application attempts to read events after each XPutImage call,
then then the server's event buffers should never overflow.

What Burns was suspicious about was that Xlib reported that 27423744
requests had been processed.  It seems highly unlikely that one program
can generate that many requests in 30 seconds, especially if they are
"heavy" requests like XPutImage!

> You might try slowing it down with a lib$wait and see if you aren't 
> just overpowering the server and overflowing its queue.  An 8800 
> against a uvII is pretty uneven.

    I tried doing a X$Synchronize every 30 cycles.
    It blew up at about the same place.

-Jeff

    I found it.... I was sending some out of range values to XPutPixel.
    It just hppened to take a while unitl it hammered my display data.

    OOOOPS


    -Jeff Bell