Re: CRC in Ada?

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Jim Balter said

<<Instead of being stupid about it, how about just looking at the
getchar macro, which is virtually the same on every single system?
I've done this repeatedly over the last nearly 20 years on many many
systems.  There is a small overhead per byte due to the getchar
macro, which is reduced with good optimizing compilers and good
caching hardware.  For the inner loop of "cat", the getchar cost
predominates.  For anything else, it doesn't.  This is basic
algorithmic analysis, which you can find good references for in your
local library, if you ever bother to head in that direction.>>

(replying to me)

Very curious, your post EXACTLY agrees with my point, which is that
there is extra overhead, even in C in going character by character, 
and you even go so far as to say (further than I went) that there
can be programs in which this effect is dominant.

Well of course your claim that ONLY cat can see this effect is 
over-headed hyperbole, but there is a real difference, and for
example, in many of the compilers I have written in C, I have
found that the overall compilation time is noticably affected by
the choice of reading character by character or reading blocks.
A character read is going to do at least one pipe-line breaking
test (or one should say potentially pipe-line breaking test),
and it is not going to be free.

That was my point, and you seem to completely agree, and I really
don't see what algorithmic analysis has to do with the situation,
since we are talking O(N) in any case, i.e. we are discussing
constants, not algorithmic complexities