xenocara/app/xgc/tests.c
2010-10-31 19:41:34 +00:00

641 lines
15 KiB
C

/*
**
*/
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Xaw/AsciiText.h>
#include <X11/Xos.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "xgc.h"
#ifdef SVR4
#define SYSV
#endif
#if !defined(SYSV) && !defined(QNX4)
#include <sys/timeb.h>
#include <sys/resource.h>
#endif
#ifndef PI
#define PI 3.14159265
#endif
#ifdef SYSV
#define random lrand48
#endif
/* timer(flag)
** -----------
** When called with StartTimer, starts the stopwatch and returns nothing.
** When called with EndTimer, stops the stopwatch and returns the time
** in microseconds since it started.
**
** Uses rusage() so we can subtract the time used by the system and user
** from our timer, and just concentrate on the time used in the X calls.
*/
static long
timer(int flag)
{
#if !defined(SYSV)
static struct timeval starttime; /* starting time for gettimeofday() */
struct timeval endtime; /* ending time for gettimeofday() */
#if !defined(__UNIXOS2__) && !defined(QNX4)
static struct rusage startusage; /* starting time for getrusage() */
struct rusage endusage; /* ending time for getrusage() */
#endif
struct timezone tz; /* to make gettimeofday() happy */
long elapsedtime; /* how long since we started the timer */
switch (flag) {
case StartTimer: /* store initial values */
gettimeofday(&starttime,&tz);
#if !defined(__UNIXOS2__) && !defined(QNX4)
getrusage(RUSAGE_SELF,&startusage);
#endif
return((long) NULL);
case EndTimer:
gettimeofday(&endtime,&tz); /* store final values */
#if !defined(__UNIXOS2__) && !defined(QNX4)
getrusage(RUSAGE_SELF,&endusage);
#endif
/* all the following line does is use the formula
elapsed time = ending time - starting time, but there are three
different timers and two different units of time, ack... */
#if !defined(__UNIXOS2__) && !defined(QNX4)
elapsedtime = (long) ((long)
((endtime.tv_sec - endusage.ru_utime.tv_sec - endusage.ru_stime.tv_sec
- starttime.tv_sec + startusage.ru_utime.tv_sec
+ startusage.ru_stime.tv_sec)) * 1000000) + (long)
((endtime.tv_usec - endusage.ru_utime.tv_usec - endusage.ru_stime.tv_usec
- starttime.tv_usec + startusage.ru_utime.tv_usec
+ startusage.ru_stime.tv_usec));
#else
elapsedtime = (long)( ((long)endtime.tv_sec-(long)starttime.tv_sec)*1000000
+((long)endtime.tv_usec-(long)starttime.tv_usec));
#endif
return(elapsedtime);
default:
fprintf(stderr,"Invalid flag in timer()\n");
return((long) NULL);
}
#else
static time_t starttime;
switch (flag) {
case StartTimer:
time(&starttime);
return((long) NULL);
case EndTimer:
return( (time(NULL) - starttime) * 1000000);
default:
fprintf(stderr,"Invalid flag in timer()\n");
return((long) NULL);
}
#endif
}
void
copyarea_test(void)
{
int num_copies = 200;
int i;
long totaltime;
char buf[80];
num_copies *= X.percent;
XSetFillStyle(X.dpy,X.miscgc,FillTiled);
XFillRectangle(X.dpy,X.win,X.miscgc,0,0,400,400);
XSync(X.dpy,0);
timer(StartTimer);
for (i=0;i<num_copies;++i)
XCopyArea(X.dpy,X.win,X.win,X.gc,i,200-i,
200,200,200-i,i);
XSync(X.dpy,0);
totaltime = timer(EndTimer);
snprintf(buf,sizeof buf,"%.2f seconds.",(double)totaltime/1000000.);
show_result(buf);
}
void
copyplane_test(void)
{
int num_copies = 200;
int i;
long totaltime;
char buf[80];
if(!X.gcv.plane_mask || (X.gcv.plane_mask & (X.gcv.plane_mask - 1))) {
show_result("exactly one bit in plane mask must be set for this test");
return;
}
num_copies *= X.percent;
XSetPlaneMask(X.dpy, X.gc, ~0L);
XSetFillStyle(X.dpy,X.miscgc,FillTiled);
XFillRectangle(X.dpy,X.win,X.miscgc,0,0,400,400);
XSync(X.dpy,0);
timer(StartTimer);
for (i=0;i<num_copies;++i)
XCopyPlane(X.dpy,X.win,X.win,X.gc,i,200-i,
200,200,200-i,i,X.gcv.plane_mask);
XSync(X.dpy,0);
totaltime = timer(EndTimer);
XSetPlaneMask(X.dpy, X.gc, X.gcv.plane_mask);
snprintf(buf,sizeof buf,"%.2f seconds.",(double)totaltime/1000000.);
show_result(buf);
}
void
circle_line_test(int num_vertices, int radius)
{
double theta, delta;
int length, centerx, centery, i;
int relative_angle;
long totaltime;
char buf[80];
XPoint *coord;
relative_angle = num_vertices*5/12+1;
delta = (double) relative_angle / (double) num_vertices * 2 * PI;
centerx = centery = 200;
coord = (XPoint *) malloc (sizeof(XPoint)*(num_vertices+1));
length = (int) (2 * radius * (float) atan(delta/2.));
for (i=0;i<=num_vertices;++i) {
theta = (double) i * delta;
coord[i].x = centerx + (int) (radius * cos(theta));
coord[i].y = centery + (int) (radius * sin(theta));
}
XSync(X.dpy,0);
timer(StartTimer);
XDrawLines(X.dpy,X.win,X.gc,coord,num_vertices+1,CoordModeOrigin);
XSync(X.dpy,0);
totaltime = timer(EndTimer);
snprintf(buf,sizeof buf,"%d lines of length %d in %.3f seconds.",num_vertices,
length,(double)totaltime/1000000.);
show_result(buf);
free(coord);
}
void
polyline_test(void)
{
circle_line_test((int)(601*X.percent),190);
}
void
polysegment_test(void)
{
XSegment *segments;
int num_segments = 600;
long totaltime;
char buf[80];
int i;
num_segments *= X.percent;
segments = (XSegment *) malloc(sizeof(XSegment) * num_segments);
segments[0].x1 = random()%400; segments[0].y1 = random()%400;
segments[0].x2 = random()%400; segments[0].y2 = random()%400;
for(i=1;i<num_segments;++i) {
segments[i].x1 = (segments[i-1].x1-segments[i-1].y2+400+i)%400;
segments[i].y1 = (segments[i-1].y1+segments[i-1].x2+i)%400;
segments[i].x2 = (segments[i-1].x1-segments[i-1].y1+400+i)%400;
segments[i].y2 = (segments[i-1].x2+segments[i-1].y2+i)%400;
}
XSync(X.dpy,0);
start_timer();
XDrawSegments(X.dpy,X.win,X.gc,segments,num_segments);
XSync(X.dpy,0);
totaltime = end_timer();
snprintf(buf,sizeof buf,"%d segments in %.3f seconds.",num_segments,
(double)totaltime/1000000.);
show_result(buf);
free(segments);
}
void
polypoint_test(void)
{
XPoint *points;
int num_points = 100000;
long totaltime;
char buf[80];
int i;
num_points *= X.percent;
points = (XPoint *) malloc(sizeof(XPoint) * num_points);
points[0].x = random()%400; points[0].y = random()%400;
points[1].x = random()%400; points[1].y = random()%400;
for (i=2;i<num_points;++i) {
points[i].x = (points[i-1].x+points[i-2].y+i*3/200)%400;
points[i].y = (points[i-1].y+points[i-2].x+i*5/200)%400;
}
XSync(X.dpy,0);
start_timer();
XDrawPoints(X.dpy,X.win,X.gc,points,num_points,CoordModeOrigin);
XSync(X.dpy,0);
totaltime = end_timer();
snprintf(buf,sizeof buf,"%d points in %.3f seconds.",num_points,
(double)totaltime/1000000.);
show_result(buf);
free(points);
}
void
genericrectangle_test(Boolean fill)
{
XRectangle *rects;
int num_rects = 200;
int perimeter = 0, area = 0;
int i;
long totaltime;
char buf[80];
num_rects *= X.percent;
rects = (XRectangle *) malloc(sizeof(XRectangle) * num_rects);
for (i=0;i<num_rects;++i) {
rects[i].x = rects[i].y = 200 - i;
rects[i].width = rects[i].height = 2 * i;
perimeter += rects[i].width * 2 + rects[i].height * 2;
area += rects[i].width * rects[i].height;
}
XSync(X.dpy,0);
start_timer();
if (fill) XFillRectangles(X.dpy,X.win,X.gc,rects,num_rects);
else XDrawRectangles(X.dpy,X.win,X.gc,rects,num_rects);
XSync(X.dpy,0);
totaltime = end_timer();
if (fill)
snprintf(buf,sizeof buf,"%d pixels in %.2f seconds.",area,(double)totaltime/1000000.);
else
snprintf(buf,sizeof buf,"Total line length %d in %.3f seconds.",perimeter,
(double)totaltime/1000000.);
show_result(buf);
free(rects);
}
void
polyrectangle_test(void)
{
genericrectangle_test(FALSE);
}
void
polyfillrectangle_test(void)
{
genericrectangle_test(TRUE);
}
/*****************************/
void
fillpolygon_test(void)
{
int i;
int points_per_side = 40;
int spacing;
XPoint *points;
XPoint polypoints[3];
points = (XPoint *) malloc (sizeof(XPoint) * points_per_side * 4);
spacing = 400 / points_per_side;
for (i = 0; i < points_per_side; ++i) {
points[i].x = i * spacing;
points[i].y = 0;
points[i + points_per_side].x = 400;
points[i + points_per_side].y = i * spacing;
points[i + 2 * points_per_side].x = 400 - i * spacing;
points[i + 2 * points_per_side].y = 400;
points[i + 3 * points_per_side].x = 0;
points[i + 3 * points_per_side].y = 400 - i * spacing;
}
for (i = 0; i < 2 * points_per_side; i += 2) {
polypoints[0].x = points[i].x;
polypoints[0].y = points[i].y;
polypoints[1].x = points[i + 2 * points_per_side].x;
polypoints[1].y = points[i + 2 * points_per_side].y;
polypoints[2].x = points[i + 2 * points_per_side + 1].x;
polypoints[2].y = points[i + 2 * points_per_side + 1].y;
XFillPolygon (X.dpy, X.win, X.gc, polypoints, 3, Convex, CoordModeOrigin);
}
free(points);
}
/*****************************/
void
genericarc_test(Boolean fill)
{
XArc *arcs;
int num_arcs = 180;
int i;
long totaltime;
char buf[80];
num_arcs *= X.percent;
arcs = (XArc *) malloc(sizeof(XArc) * num_arcs);
for (i=0;i<num_arcs;++i) {
arcs[i].x = i;
arcs[i].y = i;
arcs[i].width = i;
arcs[i].height = i;
arcs[i].angle1 = i * 128;
arcs[i].angle2 = i * 128;
}
XSync(X.dpy,0);
start_timer();
if (fill) XFillArcs(X.dpy,X.win,X.gc,arcs,num_arcs);
else XDrawArcs(X.dpy,X.win,X.gc,arcs,num_arcs);
XSync(X.dpy,0);
totaltime = end_timer();
snprintf(buf,sizeof buf,"An uncounted number of pixels in %.3f seconds.",
(double)totaltime/1000000.);
show_result(buf);
free(arcs);
}
void
polyarc_test(void)
{
genericarc_test(FALSE);
}
void
polyfillarc_test(void)
{
genericarc_test(TRUE);
}
static const char string8[] = "pack my box with five dozen liquor jugs";
void
polytext8_test(void)
{
int num_strings = 200;
int i;
long totaltime;
char buf[80];
num_strings *= X.percent;
XSync(X.dpy,0);
start_timer();
for (i=0;i<num_strings;++i) {
XDrawString(X.dpy,X.win,X.gc,(i%2 ? i : num_strings - i),i,
string8,sizeof(string8)-1);
}
XSync(X.dpy,0);
totaltime = end_timer();
snprintf(buf,sizeof buf,"%d strings in %.2f seconds.",num_strings,
(double) totaltime/1000000.);
show_result(buf);
}
void
imagetext8_test(void)
{
int num_strings = 200;
int i;
long totaltime;
char buf[80];
num_strings *= X.percent;
XSync(X.dpy,0);
start_timer();
for (i=0;i<num_strings;++i) {
XDrawImageString(X.dpy,X.win,X.gc,(i%2 ? i : num_strings - i),i,
string8,sizeof(string8)-1);
}
XSync(X.dpy,0);
totaltime = end_timer();
snprintf(buf,sizeof buf,"%d strings in %.2f seconds.",num_strings,
(double) totaltime/1000000.);
show_result(buf);
}
static char unicode_font[] =
"-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1";
static const XChar2b string16[] = {
{ 0x00, 0x20 }, { 0x00, 0x20 }, { 0x22, 0x2E }, { 0x00, 0x20 },
{ 0x00, 0x45 }, { 0x22, 0xC5 }, { 0x00, 0x64 }, { 0x00, 0x61 },
{ 0x00, 0x20 }, { 0x00, 0x3D }, { 0x00, 0x20 }, { 0x00, 0x51 },
{ 0x00, 0x2C }, { 0x00, 0x20 }, { 0x00, 0x20 }, { 0x00, 0x6E },
{ 0x00, 0x20 }, { 0x21, 0x92 }, { 0x00, 0x20 }, { 0x22, 0x1E },
{ 0x00, 0x2C }, { 0x00, 0x20 }, { 0x22, 0x11 }, { 0x00, 0x20 },
{ 0x00, 0x66 }, { 0x00, 0x28 }, { 0x00, 0x69 }, { 0x00, 0x29 },
{ 0x00, 0x20 }, { 0x00, 0x3D }, { 0x00, 0x20 }, { 0x22, 0x0F },
{ 0x00, 0x20 }, { 0x00, 0x67 }, { 0x00, 0x28 }, { 0x00, 0x69 },
{ 0x00, 0x29 }, { 0x00, 0x2C }, { 0x00, 0x20 }, { 0x22, 0x00 },
{ 0x00, 0x78 }, { 0x22, 0x08 }, { 0x21, 0x1D }, { 0x00, 0x3A },
{ 0x00, 0x20 }, { 0x23, 0x08 }, { 0x00, 0x78 }, { 0x23, 0x09 },
{ 0x00, 0x20 }, { 0x00, 0x3D }, { 0x00, 0x20 }, { 0x22, 0x12 },
{ 0x23, 0x0A }, { 0x22, 0x12 }, { 0x00, 0x78 }, { 0x23, 0x0B },
{ 0x00, 0x2C }, { 0x00, 0x20 }, { 0x03, 0xB1 }, { 0x00, 0x20 },
{ 0x22, 0x27 }, { 0x00, 0x20 }, { 0x00, 0xAC }, { 0x03, 0xB2 },
{ 0x00, 0x20 }, { 0x00, 0x3D }, { 0x00, 0x20 }, { 0x00, 0xAC },
{ 0x00, 0x28 }, { 0x00, 0xAC }, { 0x03, 0xB1 }, { 0x00, 0x20 },
{ 0x22, 0x28 }, { 0x00, 0x20 }, { 0x03, 0xB2 }, { 0x00, 0x29 },
{ 0x00, 0x2C }
};
void
polytext16_test(void)
{
int num_strings = 50;
int i;
long totaltime;
char buf[80];
num_strings *= X.percent;
GC_change_font(unicode_font,FALSE);
XSync(X.dpy,0);
start_timer();
for (i=0;i<num_strings;++i) {
XDrawString16(X.dpy,X.win,X.gc,(i%2 ? i : num_strings - i),10*i,
string16,sizeof(string16)/sizeof(XChar2b));
}
XSync(X.dpy,0);
totaltime = end_timer();
GC_change_font(X.fontname,FALSE);
snprintf(buf,sizeof buf,"%d strings in %.2f seconds.",num_strings,
(double) totaltime/1000000.);
show_result(buf);
}
void
imagetext16_test(void)
{
int num_strings = 50;
int i;
long totaltime;
char buf[80];
num_strings *= X.percent;
GC_change_font(unicode_font,FALSE);
XSync(X.dpy,0);
start_timer();
for (i=0;i<num_strings;++i) {
XDrawImageString16(X.dpy,X.win,X.gc,(i%2 ? i : num_strings - i),10*i,
string16,sizeof(string16)/sizeof(XChar2b));
}
XSync(X.dpy,0);
totaltime = end_timer();
GC_change_font(X.fontname,FALSE);
snprintf(buf,sizeof buf,"%d strings in %.2f seconds.",num_strings,
(double) totaltime/1000000.);
show_result(buf);
}
void
putimage_test(void)
{
int num_copies = 200;
int i;
long totaltime;
char buf[80];
num_copies *= X.percent;
XSetFillStyle(X.dpy,X.miscgc,FillTiled);
XFillRectangle(X.dpy,X.win,X.miscgc,0,0,400,400);
X.image = XGetImage(X.dpy,X.win,0,0,200,200,~0,XYPixmap);
XSync(X.dpy,0);
timer(StartTimer);
for (i=0;i<num_copies;++i)
XPutImage(X.dpy,X.win,X.gc,X.image,0,0,i,i,200,200);
XSync(X.dpy,0);
totaltime = timer(EndTimer);
snprintf(buf,sizeof buf,"%.2f seconds.",(double)totaltime/1000000.);
show_result(buf);
}
/*****************************/
/*****************************/
void
run_test(void)
{
XClearWindow(X.dpy,X.win);
print_if_recording("run\n");
switch (X.test) {
case CopyArea: copyarea_test(); break;
case CopyPlane: copyplane_test(); break;
case PolyPoint: polypoint_test(); break;
case PolyLine: polyline_test(); break;
case PolySegment: polysegment_test(); break;
case PolyRectangle: polyrectangle_test(); break;
case PolyArc: polyarc_test(); break;
case FillPolygon: fillpolygon_test(); break;
case PolyFillRect: polyfillrectangle_test(); break;
case PolyFillArc: polyfillarc_test(); break;
case PolyText8: polytext8_test(); break;
case ImageText8: imagetext8_test(); break;
case PolyText16: polytext16_test(); break;
case ImageText16: imagetext16_test(); break;
case PutImage: putimage_test(); break;
default: fprintf(stderr,"That test doesn't exist yet.\n");
}
}
/*****************************/
/* set_text(w,string)
** ------------------
** Sets the text in a read-only text widget to the specified string.
*/
void
set_text(Widget w, char *string)
{
static Arg args[2];
XtSetArg(args[0], XtNstring, string);
XtSetArg(args[1], XtNlength, strlen(string));
XtSetValues(w, args, (Cardinal) 2 );
}
void
show_result(char *string)
{
char buf[80];
set_text(result,string);
strcpy(buf,"# ");
strncat(buf,string,sizeof(buf) - 3);
buf[sizeof(buf) - 3] = '\0';
strcat(buf,"\n");
print_if_recording(buf);
}