News for hackers. Stuff that matters.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by mikelward on Tuesday July 19, 2011 @10:08AM (#2780947)
"adds the argv into a buffer (why?)"

It's calling "write", which is a system call. Without the buffer, it would call write once for argv, and once for the newline if nflag is not set. Calling a system call twice would result in twice as many context switches, and thus be very slightly slower.

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by scythe on Tuesday July 19, 2011 @10:22AM (#2781005)
Oh, that makes sense.

Speaking of clever tricks, would it be faster or slower to use c99's variable-length arrays instead of malloc?

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by alexgartrell on Tuesday July 19, 2011 @11:32AM (#2781319)
IIRC faster, because variable-length arrays in c99 just bump down the stack pointer, while malloc can be pretty expensive.

But a single malloc is nothing compared to the cost of a context switch into kernel mode.

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by apaprocki on Tuesday July 19, 2011 @12:34PM (#2781656)
You can simply use alloca() as a replacement for malloc() to avoid depending on VLA support.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by tedunangst on Tuesday July 19, 2011 @01:59PM (#2782178)
alloca sucks. The error handling is "haha, you overflowed your stack." (VLA sucks for the same reason.)
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by cpeterso on Tuesday July 19, 2011 @01:18PM (#2781924)
Or just declare a large static buffer.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by tedunangst on Tuesday July 19, 2011 @01:55PM (#2782156)
"Nobody will ever echo this much data!"
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by tmp43522 on Tuesday July 19, 2011 @03:04PM (#2782545)
It's actually not a bad suggestion

    #define BUF_INITIAL 1024
    char buf[BUF_INITIAL];
    
    int main(int argc, char** argv)
    {
        char* p;
        ...
        p = len > BUF_INITIAL ? malloc(len) : buf;
        ...
        write(1, p, len);
        ...
    }
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by cpeterso on Tuesday July 19, 2011 @04:04PM (#2782821)
djb's allocator alloc() does this. He preallocates a 4 KB static buffer before hitting system malloc(). Avoiding the overhead of malloc() is pretty important for the performance of systems like qmail that fork many small processes.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by tedunangst on Tuesday July 19, 2011 @04:56PM (#2783038)
That's ridiculous. The overhead of fork is about a bajillion times higher than malloc.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by adestefan on Tuesday July 19, 2011 @10:40PM (#2784080)
With a COW fork() I bet it's smaller. I smell a test coming on, but alas it's late here and I'm going to bed.

I'm also guessing that 4k was chosen because a malloc() of 1 page is faster than a malloc() of >1 page. Of course that's with the assumption that the systems use a 4k page size.

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by aidenn0 on Tuesday July 19, 2011 @08:44PM (#2783776)
Are you sure? I'd bet it's greater, I'd not bet that it's an order of magnitude better, fork() has been optimized a lot more than brk().
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by sliverstorm on Tuesday July 19, 2011 @04:42PM (#2782986)
Many small processes? How many?

4 KB * (many) could be frightening.

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by jff on Tuesday July 19, 2011 @06:34PM (#2783436)
If your system has 32,000 processes and you allocate 4 KB to each of them... that's 128 MB. I'm not crapping my pants at that figure because even the oldest machine in my office, an old Thinkpad, has 2 GB of RAM.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by GreySyntax on Tuesday July 19, 2011 @02:44PM (#2782430)
Oh wait they will
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by Someone on Tuesday July 19, 2011 @06:16PM (#2783376)
If speed is important, why the copying of the data? Only 'slightly' non-portable:

  int main (int argc, const char * argv[])
  {
    for( int i = 1; i < argc; ++i)
    {
        ((char *)argv[i])[-1] = ' ';
    }
    size_t len = strlen(argv[argc - 1]);
    ((char *)argv[argc - 1])[len] = '\n';
    write(1, argv[1], argv[argc - 1] - argv[1] + len + 1);
    return EXIT_SUCCESS;
  }
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by ori_b on Wednesday July 20, 2011 @01:22AM (#2784424)
It has to do with the way plan9 guarantees atomic writes of small buffers. A single write() call will correspond to a single read() call if the buffer is big enough to receive it.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by haberman on Tuesday July 19, 2011 @11:14AM (#2781254)
Isn't that what stdio is for (fopen()/fread()/fwrite()/etc)? It performs buffering for you.
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by p9idf on Tuesday July 19, 2011 @11:52AM (#2781419)
Stdio would add unnecessary overhead. And why bother with stdio (or its Plan 9 equivalent) when it's so easy to do the buffering faster yourself?
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by haberman on Tuesday July 19, 2011 @06:09PM (#2783349)
Overhead such as...? The only one I can think of is the mutex lock/unlock, but there are the _unlocked variants for those.

"And why bother with stdio (or its Plan 9 equivalent) when it's so easy to do the buffering faster yourself?"

For the same reason you'd use any abstraction: to keep your program simpler. Even if you consider it "so easy" there are plenty of opportunities there for off-by-one errors and buffer overflows that would disappear if you used stdio instead.

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by bodyfour on Wednesday July 20, 2011 @12:05AM (#2784253)
Remember that echo.c evolved long before UNIX has shared libraries. So avoiding stdio completely might mean the size of your binary drops from 50K to 5K. If you're on a PDP-11 with 256KB of RAM (being shared by several users) this would make a big difference.

My earliest UNIX programming was in the mid-80s on a machine with a (luxurious!) 1.5MB of RAM. I definitely remember avoiding stdio when writing small utilities that I wanted to start up and run fast.

Also remember that back in those days echo was not a shell builtin. (Hell, back then the testing operator '[' wasn't even a builtin. Some UNIXes like OS/X still have a vestigial /bin/[ executable!) Programs like echo that ran from shell scripts constantly had to be coded to start up as fast as possible.

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by dchest on Wednesday July 20, 2011 @08:07AM (#2785120)
This was actually the reason for FreeBSD's more complicated version. Revision 106835:

    Put echo on a diet, removing unnecessary use of stdio and getopt.
    
    Before...
    -r-xr-xr-x  1 root  wheel  58636 Oct 28 05:16 /bin/echo
    After...
    -rwxr-xr-x  1 root  wheel  12824 Nov 12 17:39 /usr/obj/usr/src/bin/echo/echo
http://svnweb.freebsd.org/base?view=revision&revision=10...
Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by EdiX on Wednesday July 20, 2011 @03:05AM (#2784637)
> Some UNIXes like OS/X still have a vestigial /bin/[ executable!

This includes linux, but it's in /usr/bin/[

Re:Unix V5, OpenBSD, Plan 9, FreeBSD, and GNU implementation... by p9idf on Tuesday July 19, 2011 @06:31PM (#2783430)
Please point out the plentiful opportunities for off-by-one errors in Plan 9's echo.c. If you send me a copy of Plan 9's echo.c using stdio I will run it and benchmark it for you.