head 1.3; access; symbols SFIO_1999:1.1.1.3 SFIO_1998:1.1.1.2 SFIO_1997:1.1.1.1 ATT:1.1.1; locks; strict; comment @# @; 1.3 date 99.09.11.13.20.42; author rse; state Exp; branches; next 1.2; 1.2 date 99.09.11.12.42.09; author rse; state Exp; branches; next 1.1; 1.1 date 96.12.13.01.52.38; author rse; state Exp; branches 1.1.1.1; next ; 1.1.1.1 date 96.12.13.01.52.38; author rse; state Exp; branches; next 1.1.1.2; 1.1.1.2 date 98.03.20.02.46.53; author rse; state Exp; branches; next 1.1.1.3; 1.1.1.3 date 99.07.30.13.22.08; author rse; state Exp; branches; next ; desc @@ 1.3 log @Merge in Sfio 1999 changes @ text @################################################################## # This file defines probes for local features that sfio requires. # Such probes are interpreted by the "iffe" language interpreter. # Results are stored in the FEATURE directory. # Written by Kiem-Phong Vo (06/27/92). # Converted to sfio v10/01/94 by Giampiero Sierra (06/08/95). ################################################################## hdr unistd hdr string hdr math lib qfrexp lib qldexp # hdr values hdr floatingpoint hdr float lib atexit lib onexit lib lseek64 lib stat64 lib mmap64 typ off64_t typ struct_stat64 compile{ #include #include main() { struct stat64 statb; } }end exit cleanup note{ stuck with standard _cleanup }end execute{ #include _BEGIN_EXTERNS_ extern void exit _ARG_((int)); extern void _exit _ARG_((int)); extern void _cleanup(); void _cleanup() { _exit(0); } _END_EXTERNS_ main() { printf("cleanup\n"); exit(1); } }end lib bcopy lib bzero lib memcpy lib memset lib memalign hdr time sys time lib memchr note{ see if memchr is fast }end execute{ #include #include #include main() { struct tms stm1, etm1, stm2, etm2; register int i, p; register char *s, *ends; long t1, t2; char buf[128]; for(p = 0; p < 100; ++p) buf[p] = '0' + (p%10); buf[p++] = '\n'; buf[p] = 0; times(&stm1); for(i = 0; i < 100000; ++i) s = memchr(buf,'\n',p); times(&etm1); times(&stm2); for(i = 0; i < 100000; ++i) { ends = (s = buf) + p; while(*s != '\n') if((s += 1) == ends) break; } times(&etm2); t1 = (etm1.tms_utime - stm1.tms_utime) + (etm1.tms_stime - stm1.tms_stime); t2 = (etm2.tms_utime - stm2.tms_utime) + (etm2.tms_stime - stm2.tms_stime); return t1 < t2 ? 0 : 1; } }end lib memccpy note{ see if memccpy is fast }end execute{ #include #include #include main() { struct tms stm1, etm1, stm2, etm2; register int i, p; register char *s1, *s2; long t1, t2; char buf1[128], buf2[128]; for(i = 0; i < 100; ++i) buf1[i] = '0' + (i%10); buf1[i++] = '\n'; buf1[i] = 0; times(&stm1); for(i = 0; i < 100000; ++i) { p = 128; memccpy(buf2,buf1,'\n',p); } times(&etm1); times(&stm2); for(i = 0; i < 100000; ++i) { s1 = buf1; s2 = buf2; p = 128; while((*s2++ = *s1++) != '\n' && --p > 0) ; } times(&etm2); t1 = (etm1.tms_utime - stm1.tms_utime) + (etm1.tms_stime - stm1.tms_stime); t2 = (etm2.tms_utime - stm2.tms_utime) + (etm2.tms_stime - stm2.tms_stime); return t1 < t2 ? 0 : 1; } }end sys stat note{ stat() in default lib(s) }end link{ #if _STD_ #include #else #include #endif #include #include main() { struct stat st; fstat(0,&st); } }end hdr stat note{ stat() in default lib(s) }end link{ #if _STD_ #include #else #include #endif #include #include main() { struct stat st; fstat(0,&st); } }end ############################################################# # See if memory mapping is available and fast enough to use ############################################################# sys mman tst output{ #include #include #include _BEGIN_EXTERNS_ int creat _ARG_((char*, int)); int open _ARG_((char*, int)); int unlink _ARG_((char*)); int read _ARG_((int, char*, int)); _END_EXTERNS_ #define MAPSIZE (64*1024) #define BUFSIZE (MAPSIZE/8) #define WRITE (64) #define RUN (64) #define Failed(file) (unlink(file),1) #if _STD_ main(int argc, char** argv) #else main(argc,argv) int argc; char** argv; #endif { caddr_t mm; char *t, *f; int i, fd, k, run; char file[1024], buf[MAPSIZE]; struct tms stm, etm; clock_t rdtm, mmtm; /* create data file */ f = argv[0]; t = file; while (*t = *f++) t++; *t++ = '.'; *t++ = 'D'; *t = 0; if ((fd = creat(file,0666)) < 0) return 1; for (i = 0; i < sizeof(buf); ++i) buf[i] = '0' + (i%10); for (i = 0; i < WRITE; ++i) if (write(fd,buf,sizeof(buf)) != sizeof(buf)) return Failed(file); close(fd); /* read time */ times(&stm); for(run = 0; run < RUN; ++run) { if((fd = open(file, 0)) < 0) return Failed(file); for (i = 0; i < WRITE; ++i) { for(k = 0; k < MAPSIZE; k += BUFSIZE) if (read(fd,buf,BUFSIZE) != BUFSIZE) return Failed(file); } close(fd); } times(&etm); rdtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime); /* mmap time */ times(&stm); for(run = 0; run < RUN; ++run) { if ((fd = open(file,0)) < 0) return Failed(file); for(i = 0, mm = (caddr_t)0; i < WRITE; ++i) { if(mm) munmap(mm, MAPSIZE); mm = (caddr_t)mmap((caddr_t)0, MAPSIZE, (PROT_READ|PROT_WRITE), MAP_PRIVATE, fd, i*MAPSIZE ); if(mm == (caddr_t)(-1) || mm == (caddr_t)0) return Failed(file); /* the memcpy is < BUFSIZE to simulate the fact that functions like sfreserve/sfgetr do not do buffer copying. */ t = (char*)mm; for(k = 0; k < MAPSIZE; k += BUFSIZE, t += BUFSIZE) memcpy(buf,t,(3*BUFSIZE)/4); } close(fd); } times(&etm); mmtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime); unlink(file); if(4*mmtm <= 3*rdtm) printf("#define _mmap_worthy 2 /\* mmap is great! */\\n"); else if(4*mmtm <= 5*rdtm) printf("#define _mmap_worthy 1 /\* mmap is good! */\\n"); return 0; } }end ################################################## # vfork and any associated header files ################################################## hdr vfork sys vfork lib vfork ################################################## # file control checks ################################################## hdr filio sys filio sys ioctl lib remove lib unlink lib waitpid lib getpagesize tmp rmfail note{ file not removable if still opened }end execute{ #include _BEGIN_EXTERNS_ extern int creat _ARG_((char*, int)); extern int unlink _ARG_((char*)); extern int write _ARG_((int, char*, int)); _END_EXTERNS_ main() { int fw, fr; char file[128]; sprintf(file,"/tmp/iffe%lu",(unsigned long)time(0)); if((fw = creat(file,0666)) < 0) return 0; if((fr = open(file,0)) < 0 ) return 0; if(unlink(file) < 0) return 0; if(write(fw,"0123456789",11) != 11 ) return 0; if(read(fr,file,11) != 11) return 0; if(strcmp(file,"0123456789") != 0) return 0; return 1; } }end more void_int note{ voidptr is larger than int }end execute{ main() { return sizeof(char*) > sizeof(int) ? 0 : 1; } }end more long_int note{ long is larger than int }end execute{ main() { return sizeof(long) > sizeof(int) ? 0 : 1; } }end ################################################################ # See if there is a preferred block size for a file system ################################################################ stat blksize note{ st_blksize is a field in struct stat }end compile{ #include #include main () { struct stat sb; sb.st_blksize = 0; return 0; } }end ################################################## # See if certain prototypes are required ################################################## proto open note{ open() has a vararg prototype }end compile{ #include #include #include #include _BEGIN_EXTERNS_ extern int open _ARG_((const char*,int,...)); _END_EXTERNS_ main() { open("file",0); open("file",0,1); } }end proto bcopy note{ bcopy() has prototype }end compile{ #include main() { char buf[128]; bcopy(buf, "abc", 3); } }end proto bzero note{ bzero() has prototype }end compile{ #include main() { char buf[128]; bzero(buf, 128); } }end lib poll_fd_1 note{ fd is first arg to poll() }end execute{ #include _BEGIN_EXTERNS_ extern int pipe _ARG_((int*)); _END_EXTERNS_ main() { int rw[2]; struct pollfd fd; if (pipe(rw) < 0) return 1; fd.fd = rw[0]; fd.events = POLLIN; fd.revents = 0; return poll(&fd, 1, 0) < 0; } }end lib poll_fd_2 note{ fd is second arg to poll() }end execute{ #include _BEGIN_EXTERNS_ extern int pipe _ARG_((int*)); _END_EXTERNS_ main() { int rw[2]; struct pollfd fd; if (pipe(rw) < 0) return 1; fd.fd = rw[0]; fd.events = POLLIN; fd.revents = 0; return poll(1, &fd, 0) < 0; } }end lib select note{ select() has standard 5 arg interface }end link{ #include #include #include main() { struct timeval tmb; fd_set rd; FD_ZERO(&rd); FD_SET(0,&rd); tmb.tv_sec = 0; tmb.tv_usec = 0; select(1,&rd,(fd_set*)0,(fd_set*)0,&tmb); return 0; } }end ################################################################ ## See if we can peek ahead in unseekable devices ################################################################ stream peek note{ ioctl(I_PEEK) works }end link{ #include #include main() { struct strpeek pbuf; pbuf.flags = 0; pbuf.ctlbuf.maxlen = pbuf.databuf.maxlen = pbuf.ctlbuf.len = pbuf.databuf.len = 0; pbuf.ctlbuf.buf = pbuf.databuf.buf = 0; ioctl(0,I_PEEK,&pbuf); return 0; } }end socket peek note{ recv(MSG_PEEK) works }end link{ #include #include main() { char buf[128]; recv(0,buf,sizeof(buf),MSG_PEEK); return 0; } }end ################################################################ ## See if register layout is ok for vax string operations ################################################################ vax asm note{ register layout ok for vax string operations }end execute{ main() { #ifndef vax return absurd = -1; #else register int r11, r10, r9, r8, r7, r6; r11 = r10 = r9 = r8 = r7 = r6 = -1; asm("clrw r11"); asm("clrw r10"); asm("clrw r9"); asm("clrw r8"); asm("clrw r7"); asm("clrw r6"); if(sizeof(int) != sizeof(char*) || r11 || r10 || r9 || r8 || r7 || r6 ) return -1; return 0; #endif } }end lib strtod note{ native strtod exists }end ################################################################ ## See if there is "locale" stuff for conditioning printf/scanf ################################################################ lib locale note{ Check for localeconv }end compile{ #include main() { struct lconv* lv = localeconv(); return 0; } }end @ 1.2 log @Incorporate stuff from RSE's Sfio98 variant @ text @d10 1 d12 4 d17 1 d166 1 a166 62 mmap fixed note{ mmap allows overwrite of previous fixed address }end execute{ #include #include _BEGIN_EXTERNS_ int open _ARG_((char*, int)); int unlink _ARG_((char*)); _END_EXTERNS_ #define BUFSIZE (64*1024) #define WRITE (64) #define Failed(file) (unlink(file),1) #if _STD_ main(int argc, char** argv) #else main(argc,argv) int argc; char** argv; #endif { caddr_t mm; char *t, *f; int i, fd; char file[1024], buf[BUFSIZE]; /* create data file */ f = argv[0]; t = file; while (*t = *f++) t++; *t++ = '.'; *t++ = 'D'; *t = 0; if ((fd = creat(file,0666)) < 0) return 1; for (i = 0; i < sizeof(buf); ++i) buf[i] = '0' + (i%10); for (i = 0; i < WRITE; ++i) if (write(fd,buf,sizeof(buf)) != sizeof(buf)) return Failed(file); close(fd); #ifndef MAP_VARIABLE #define MAP_VARIABLE 0 #endif if ((fd = open(file,0)) < 0) return Failed(file); mm = mmap((caddr_t)0, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_VARIABLE), fd, 0); if(mm == (caddr_t)0 || mm == (caddr_t)(-1)) return Failed(file); mm = mmap(mm, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_FIXED), fd, 0); if(mm == (caddr_t)0 || mm == (caddr_t)(-1)) return Failed(file); return 0; } }end mmap worthy note{ see if mmap exists and worth using }end execute{ d170 1 a170 1 d177 1 a177 1 d179 1 a179 1 #define BUFSIZE (8*1024) d181 2 a182 1 d184 1 a184 1 d195 1 a195 1 int i, fd, okfixed; d199 1 a199 1 d207 1 a207 1 d214 1 a214 18 /* see if can overwrite fixed map */ #ifndef MAP_VARIABLE #define MAP_VARIABLE 0 #endif if ((fd = open(file,0)) < 0) return Failed(file); mm = mmap((caddr_t)0, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_VARIABLE), fd, 0); if(mm == (caddr_t)0 || mm == (caddr_t)(-1)) return Failed(file); mm = mmap(mm, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_FIXED), fd, 0); okfixed = (mm == (caddr_t)0 || mm == (caddr_t)(-1)) ? 0 : 1; munmap(mm, sizeof(buf)); close(fd); a215 2 if((fd = open(file, 0)) < 0) return Failed(file); d217 2 a218 2 for (i = 0; i < WRITE; ++i) if (read(fd,buf,BUFSIZE) != BUFSIZE) d220 7 d228 2 a229 3 close(fd); rdtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_utime); a230 2 if ((fd = open(file,0)) < 0) return Failed(file); d232 4 a235 8 for(i = 0, mm = (caddr_t)0; i < WRITE; ++i) { if(okfixed) { mm = (caddr_t)mmap(mm, MAPSIZE, (PROT_READ|PROT_WRITE), (MAP_PRIVATE | (mm ? MAP_FIXED : MAP_VARIABLE)), fd, i*MAPSIZE ); } else d239 12 a250 3 (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_VARIABLE), fd, i*MAPSIZE ); d252 1 a252 2 if(mm == (caddr_t)(-1) || mm == (caddr_t)0) return Failed(file); d255 2 a256 1 close(fd); d258 7 a264 3 mmtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_utime); return rdtm+60 < mmtm ? 1 : 0; d358 16 @ 1.1 log @Initial revision @ text @d9 1 d11 1 a11 1 hdr values d18 8 a39 2 lib memccpy lib memchr d42 1 d46 81 d159 93 a251 20 tst lib_mmap sys/types.h sys/stat.h unistd.h fcntl.h mman.h sys/mman.h sys/times.h note{ standard mmap interface that works }end execute{ #define BUFSIZE (64*1024) #define MAPSIZE (64*1024) #define WRITE (64) #if _STD_ main(int argc, char** argv) #else main(argc,argv) int argc; char** argv; #endif { caddr_t mm; char* t; char* f; int i; int fd; char file[1024]; char buf[BUFSIZE]; struct tms brdtm, erdtm, bmmtm, emmtm; d254 69 a322 46 f = argv[0]; t = file; while (*t = *f++) t++; *t++ = '.'; *t++ = 'D'; *t = 0; /* create data file */ if ((fd = creat(file,0666)) < 0) return(1); for (i = 0; i < sizeof(buf); ++i) buf[i] = '0' + (i%10); for (i = 0; i < WRITE; ++i) if (write(fd,buf,sizeof(buf)) != sizeof(buf)) return(1); close(fd); /* read time */ if ((fd = open(file, 0)) < 0) return(1); times(&brdtm); for (i = 0; i < WRITE; ++i) if (read(fd,buf,sizeof(buf)) != sizeof(buf)) return(1); times(&erdtm); close(fd); /* memory map time */ if ((fd = open(file,0)) < 0) return(1); times(&bmmtm); mm = 0; for (i = 0; i < (WRITE/(MAPSIZE/BUFSIZE)); ++i) { mm = (caddr_t)mmap(mm, MAPSIZE, (PROT_READ|PROT_WRITE), (MAP_PRIVATE | (mm ? MAP_FIXED : 0)), fd, i*MAPSIZE ); if(mm == (caddr_t)(-1) || mm == (caddr_t)0) return(1); } times(&emmtm); close(fd); unlink(file); #define SLOP 60 rdtm = (erdtm.tms_utime-brdtm.tms_utime) + (erdtm.tms_stime-brdtm.tms_stime) + SLOP; mmtm = (emmtm.tms_utime-bmmtm.tms_utime) + (emmtm.tms_stime-bmmtm.tms_stime); if(rdtm < mmtm) return(1); d324 2 a325 2 return(0); } a523 12 lib cvt note{ native double conversions }end link{ _BEGIN_EXTERNS_ extern char* ecvt _ARG_((double, int, int*, int*)); extern char* fcvt _ARG_((double, int, int*, int*)); _END_EXTERNS_ main() { (void)ecvt(0., 0, (int*)0, (int*)0); (void)fcvt(0., 0, (int*)0, (int*)0); return 0; } }end @ 1.1.1.1 log @Import of Sfio1997 @ text @@ 1.1.1.2 log @Import of Sfio1998 @ text @a10 1 hdr floatingpoint a16 8 typ off64_t typ struct_stat64 compile{ #include #include main() { struct stat64 statb; } }end d31 2 a34 1 lib memalign a37 81 lib memchr note{ see if memchr is fast }end execute{ #include #include #include main() { struct tms stm1, etm1, stm2, etm2; register int i, p; register char *s, *ends; long t1, t2; char buf[128]; for(p = 0; p < 100; ++p) buf[p] = '0' + (p%10); buf[p++] = '\n'; buf[p] = 0; times(&stm1); for(i = 0; i < 100000; ++i) s = memchr(buf,'\n',p); times(&etm1); times(&stm2); for(i = 0; i < 100000; ++i) { ends = (s = buf) + p; while(*s != '\n') if((s += 1) == ends) break; } times(&etm2); t1 = (etm1.tms_utime - stm1.tms_utime) + (etm1.tms_stime - stm1.tms_stime); t2 = (etm2.tms_utime - stm2.tms_utime) + (etm2.tms_stime - stm2.tms_stime); return t1 < t2 ? 0 : 1; } }end lib memccpy note{ see if memccpy is fast }end execute{ #include #include #include main() { struct tms stm1, etm1, stm2, etm2; register int i, p; register char *s1, *s2; long t1, t2; char buf1[128], buf2[128]; for(i = 0; i < 100; ++i) buf1[i] = '0' + (i%10); buf1[i++] = '\n'; buf1[i] = 0; times(&stm1); for(i = 0; i < 100000; ++i) { p = 128; memccpy(buf2,buf1,'\n',p); } times(&etm1); times(&stm2); for(i = 0; i < 100000; ++i) { s1 = buf1; s2 = buf2; p = 128; while((*s2++ = *s1++) != '\n' && --p > 0) ; } times(&etm2); t1 = (etm1.tms_utime - stm1.tms_utime) + (etm1.tms_stime - stm1.tms_stime); t2 = (etm2.tms_utime - stm2.tms_utime) + (etm2.tms_stime - stm2.tms_stime); return t1 < t2 ? 0 : 1; } }end d70 20 a89 93 mmap fixed note{ mmap allows overwrite of previous fixed address }end execute{ #include #include _BEGIN_EXTERNS_ int open _ARG_((char*, int)); int unlink _ARG_((char*)); _END_EXTERNS_ #define BUFSIZE (64*1024) #define WRITE (64) #define Failed(file) (unlink(file),1) #if _STD_ main(int argc, char** argv) #else main(argc,argv) int argc; char** argv; #endif { caddr_t mm; char *t, *f; int i, fd; char file[1024], buf[BUFSIZE]; /* create data file */ f = argv[0]; t = file; while (*t = *f++) t++; *t++ = '.'; *t++ = 'D'; *t = 0; if ((fd = creat(file,0666)) < 0) return 1; for (i = 0; i < sizeof(buf); ++i) buf[i] = '0' + (i%10); for (i = 0; i < WRITE; ++i) if (write(fd,buf,sizeof(buf)) != sizeof(buf)) return Failed(file); close(fd); #ifndef MAP_VARIABLE #define MAP_VARIABLE 0 #endif if ((fd = open(file,0)) < 0) return Failed(file); mm = mmap((caddr_t)0, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_VARIABLE), fd, 0); if(mm == (caddr_t)0 || mm == (caddr_t)(-1)) return Failed(file); mm = mmap(mm, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_FIXED), fd, 0); if(mm == (caddr_t)0 || mm == (caddr_t)(-1)) return Failed(file); return 0; } }end mmap worthy note{ see if mmap exists and worth using }end execute{ #include #include #include _BEGIN_EXTERNS_ int creat _ARG_((char*, int)); int open _ARG_((char*, int)); int unlink _ARG_((char*)); int read _ARG_((int, char*, int)); _END_EXTERNS_ #define MAPSIZE (64*1024) #define BUFSIZE (8*1024) #define WRITE (64) #define Failed(file) (unlink(file),1) #if _STD_ main(int argc, char** argv) #else main(argc,argv) int argc; char** argv; #endif { caddr_t mm; char *t, *f; int i, fd, okfixed; char file[1024], buf[MAPSIZE]; struct tms stm, etm; d92 46 a137 21 /* create data file */ f = argv[0]; t = file; while (*t = *f++) t++; *t++ = '.'; *t++ = 'D'; *t = 0; if ((fd = creat(file,0666)) < 0) return 1; for (i = 0; i < sizeof(buf); ++i) buf[i] = '0' + (i%10); for (i = 0; i < WRITE; ++i) if (write(fd,buf,sizeof(buf)) != sizeof(buf)) return Failed(file); close(fd); /* see if can overwrite fixed map */ #ifndef MAP_VARIABLE #define MAP_VARIABLE 0 #endif if ((fd = open(file,0)) < 0) return Failed(file); d139 2 a140 50 mm = mmap((caddr_t)0, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_VARIABLE), fd, 0); if(mm == (caddr_t)0 || mm == (caddr_t)(-1)) return Failed(file); mm = mmap(mm, sizeof(buf), (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_FIXED), fd, 0); okfixed = (mm == (caddr_t)0 || mm == (caddr_t)(-1)) ? 0 : 1; munmap(mm, sizeof(buf)); close(fd); /* read time */ if((fd = open(file, 0)) < 0) return Failed(file); times(&stm); for (i = 0; i < WRITE; ++i) if (read(fd,buf,BUFSIZE) != BUFSIZE) return Failed(file); times(&etm); close(fd); rdtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_utime); /* mmap time */ if ((fd = open(file,0)) < 0) return Failed(file); times(&stm); for(i = 0, mm = (caddr_t)0; i < WRITE; ++i) { if(okfixed) { mm = (caddr_t)mmap(mm, MAPSIZE, (PROT_READ|PROT_WRITE), (MAP_PRIVATE | (mm ? MAP_FIXED : MAP_VARIABLE)), fd, i*MAPSIZE ); } else { if(mm) munmap(mm, MAPSIZE); mm = (caddr_t)mmap((caddr_t)0, MAPSIZE, (PROT_READ|PROT_WRITE), (MAP_PRIVATE|MAP_VARIABLE), fd, i*MAPSIZE ); } if(mm == (caddr_t)(-1) || mm == (caddr_t)0) return Failed(file); } times(&etm); close(fd); unlink(file); mmtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_utime); return rdtm+60 < mmtm ? 1 : 0; } d339 12 @ 1.1.1.3 log @Import of Sfio1999 @ text @a8 1 hdr string a9 3 lib qfrexp lib qldexp a11 1 hdr float d160 62 a221 1 tst output{ d225 1 a225 1 d232 1 a232 1 d234 1 a234 1 #define BUFSIZE (MAPSIZE/8) d236 1 a236 2 #define RUN (64) d238 1 a238 1 d249 1 a249 1 int i, fd, k, run; d253 1 a253 1 d261 1 a261 1 d268 18 a285 1 d287 2 d290 2 a291 2 for(run = 0; run < RUN; ++run) { if((fd = open(file, 0)) < 0) a292 7 for (i = 0; i < WRITE; ++i) { for(k = 0; k < MAPSIZE; k += BUFSIZE) if (read(fd,buf,BUFSIZE) != BUFSIZE) return Failed(file); } close(fd); } d294 3 a296 2 rdtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime); d298 2 d301 8 a308 4 for(run = 0; run < RUN; ++run) { if ((fd = open(file,0)) < 0) return Failed(file); for(i = 0, mm = (caddr_t)0; i < WRITE; ++i) d312 3 a314 12 (PROT_READ|PROT_WRITE), MAP_PRIVATE, fd, i*MAPSIZE ); if(mm == (caddr_t)(-1) || mm == (caddr_t)0) return Failed(file); /* the memcpy is < BUFSIZE to simulate the fact that functions like sfreserve/sfgetr do not do buffer copying. */ t = (char*)mm; for(k = 0; k < MAPSIZE; k += BUFSIZE, t += BUFSIZE) memcpy(buf,t,(3*BUFSIZE)/4); d316 2 a317 1 close(fd); d320 3 a322 1 mmtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime); d324 1 a324 8 unlink(file); if(4*mmtm <= 3*rdtm) printf("#define _mmap_worthy 2 /* mmap is great! */\\n"); else if(4*mmtm <= 5*rdtm) printf("#define _mmap_worthy 1 /* mmap is good! */\\n"); return 0; a417 16 } }end proto bcopy note{ bcopy() has prototype }end compile{ #include main() { char buf[128]; bcopy(buf, "abc", 3); } }end proto bzero note{ bzero() has prototype }end compile{ #include main() { char buf[128]; bzero(buf, 128); @