Re: Ada Shootout program for K-Nucleotide (patches)

[Ole-Hjalmar Kristensen <ole-hjalmar.kristensen@substitute_employer_here.com>]

I see the C++ version uses fgets, which is a reasonably fast way of
getting a line. Is there any reason not to use fgets?
fgets (OpenSolaris version) uses memccpy to actually copy the buffer
until the newline:

     43 extern int _filbuf();
     44 extern char *memccpy();
     45 
     46 char *
     47 fgets(ptr, size, iop)
     48 char *ptr;
     49 register int size;
     50 register FILE *iop;
     51 {
     52 	char *p, *ptr0 = ptr;
     53 	register int n;
     54 
     55 	if ( !(iop->_flag & (_IOREAD|_IORW)) ) {
     56 		iop->_flag |= _IOERR;
     57 		return (NULL);
     58 	}
     59 
     60 	for (size--; size > 0; size -= n) {
     61 		if (iop->_cnt <= 0) { /* empty buffer */
     62 			if (_filbuf(iop) == EOF) {
     63 				if (ptr0 == ptr)
     64 					return (NULL);
     65 				break; /* no more data */
     66 			}
     67 			iop->_ptr--;
     68 			iop->_cnt++;
     69 		}
     70 		n = MIN(size, iop->_cnt);
     71 		if ((p = memccpy(ptr, (char *) iop->_ptr, '\n', n)) != NULL)
     72 			n = p - ptr;
     73 		ptr += n;
     74 		iop->_cnt -= n;
     75 		iop->_ptr += n;
     76 		_BUFSYNC(iop);
     77 		if (p != NULL)
     78 			break; /* found '\n' in buffer */
     79 	}
     80 	*ptr = '\0';
     81 	return (ptr0);
     82 }
>>>>> "GB" == Georg Bauhaus <rm.dash-bauhaus@futureapps.de> writes:

    GB> Ole-Hjalmar Kristensen schrieb:
    >> Character'read could very well be slower if there is no buffering
    >> involved. The way to read efficiently is to read a large buffer
    >> (multiple of disk block size) and chop it into lines yourself.
    >> 

    GB> Indeed, stream attributes won't help.

    GB> However, replacing Text_IO.Get_Line---which we use now---
    GB> might still be considered controversial:

    GB> - Is "chopping" an acceptable interpretation of "read line by line"?

    GB> - writing a correct double buffering scheme (or a buffer
    GB>   with end-of-buffer triggers for Read_A_Line_From_Buffer)
    GB>   is still a bit of work, unless there is something we could
    GB>   copy.

    GB> A package containing a quick getline will definitely be
    GB> useful in general Unix programming, I should think.
    GB> What is being used in the Socket packages, BTW?

    GB> Equally useful will be a package for fast unbounded strings.
    GB> Replace_Slice is what prevents showcasing GNAT's Spitbol
    GB> pattern matching as one of the fastest things on this planet!

-- 
   C++: The power, elegance and simplicity of a hand grenade.