Re: Oozing poison

From:

scott@slp53.sl.home (Scott Lurndal)

Newsgroups:

comp.lang.c++

Date:

27 Jan 2012 20:29:46 GMT

Message-ID:

<ZODUq.107194$487.76393@news.usenetserver.com>

Miles Bader <miles@gnu.org> writes:

Ian Collins <ian-news@hotmail.com> writes:

The only performance impact I have ever measured from the use of
exceptions is improvement. I have been testing compilers since the mid
90s and I have only found one compiler/platform (that compiler refused
to inline any function that could throw) where exceptions had a
detrimental impact on performance.

Yeah, generally exceptions are very cheap these days, probably cheaper
than equivalently-safe explicit-return-value-checking code. I guess
some of the people decrying them may be remembering some of the
initial naive implementations using setjmp/longjmp (OK, I guess the
exception handling in MS's 32-bit ABI is still kinda of stinky).

I tried substituting a 'new uint8[xx}' call to replace a malloc with a try
catch block for bad_alloc. I then disassembled the code. One instruction
(to test the return value of the malloc) turned into:

   try {
        buf = new uint8[bufsize];
    7327: 4c 89 f7 mov %r14,%rdi
    732a: e8 f9 e0 ff ff callq 5428 <operator new[](unsigned long)@plt>
    732f: 48 89 c5 mov %rax,%rbp
    7332: 49 89 c5 mov %rax,%r13
    } catch (std::exception x) {
        iocb->set_rd(IOT_WITH_EXCEPTIONS, RD1_OCS_MPU_PARITY);
        return false;
    }

    switch (cmd) {
    7335: 45 84 e4 test %r12b,%r12b
    7338: 0f 84 8f 00 00 00 je 73cd <c_uniline_dlp::echo(c_iocb*)+0xdf>
    733e: 41 80 fc 08 cmp $0x8,%r12b
    7342: 0f 85 7e 01 00 00 jne 74c6 <c_uniline_dlp::echo(c_iocb*)+0x1d8>
    7348: e9 21 01 00 00 jmpq 746e <c_uniline_dlp::echo(c_iocb*)+0x180>
    734d: 48 89 c5 mov %rax,%rbp
    7350: 48 83 fa 01 cmp $0x1,%rdx
    7354: 74 08 je 735e <c_uniline_dlp::echo(c_iocb*)+0x70>
    7356: 48 89 c7 mov %rax,%rdi
    7359: e8 aa de ff ff callq 5208 <_Unwind_Resume@plt>
    uint8 *buf;
    uint8 cmd = iocb->get_op_var2();

    try {
        buf = new uint8[bufsize];
    } catch (std::exception x) {
    735e: 48 89 c7 mov %rax,%rdi
    7361: e8 b2 dc ff ff callq 5018 <__cxa_get_exception_ptr@plt>
   * library, and by certain language expressions. You are free to derive
   * your own %exception classes, or use a different hierarchy, or to
   * throw non-class data (e.g., fundamental types).
   */
  class exception
  {
    7366: 48 8b 05 7b 83 20 00 mov 0x20837b(%rip),%rax # 20f6e8 <_DYNAMIC+0x1c0>
    736d: 48 8d 40 10 lea 0x10(%rax),%rax
    7371: 48 89 04 24 mov %rax,(%rsp)
    7375: 48 89 ef mov %rbp,%rdi
    7378: e8 db e0 ff ff callq 5458 <__cxa_begin_catch@plt>
        iocb->set_rd(IOT_WITH_EXCEPTIONS, RD1_OCS_MPU_PARITY);
    737d: 41 b9 00 00 00 00 mov $0x0,%r9d
    7383: 41 b8 00 00 00 00 mov $0x0,%r8d
    7389: b9 00 00 00 00 mov $0x0,%ecx
    738e: ba 04 00 00 00 mov $0x4,%edx
    7393: be 00 c0 00 00 mov $0xc000,%esi
    7398: 48 89 df mov %rbx,%rdi
    739b: e8 e8 dd ff ff callq 5188 <c_iocb::set_rd(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)@plt>
    uint8 *buf;
    uint8 cmd = iocb->get_op_var2();

    try {
        buf = new uint8[bufsize];
   } catch (std::exception x) {
    73a0: 48 89 e7 mov %rsp,%rdi
    73a3: e8 30 e1 ff ff callq 54d8 <std::exception::~exception()@plt>
    73a8: e8 7b dd ff ff callq 5128 <__cxa_end_catch@plt>
    73ad: 0f 1f 00 nopl (%rax)
    73b0: e9 41 01 00 00 jmpq 74f6 <c_uniline_dlp::echo(c_iocb*)+0x208>
    73b5: 48 89 c5 mov %rax,%rbp
    73b8: 48 89 e7 mov %rsp,%rdi
    73bb: e8 18 e1 ff ff callq 54d8 <std::exception::~exception()@plt>
    73c0: e8 63 dd ff ff callq 5128 <__cxa_end_catch@plt>
    73c5: 48 89 ef mov %rbp,%rdi
    73c8: e8 3b de ff ff callq 5208 <_Unwind_Resume@plt>
        return false;
    }

    switch (cmd) {

versus (with malloc):

    buf = (uint8 *)malloc(bufsize);
    7136: 4c 89 ef mov %r13,%rdi
    7139: e8 6a dd ff ff callq 4ea8 <malloc@plt>
    713e: 48 89 c3 mov %rax,%rbx
    7141: 49 89 c6 mov %rax,%r14
    if (buf == NULL) {
    7144: 48 85 c0 test %rax,%rax
    7147: 75 28 jne 7171 <c_uniline_dlp::echo(c_iocb*)+0x73>
        iocb->set_rd(IOT_WITH_EXCEPTIONS, RD1_OCS_MPU_PARITY);
    7149: 41 b9 00 00 00 00 mov $0x0,%r9d
    714f: 41 b8 00 00 00 00 mov $0x0,%r8d
    7155: b9 00 00 00 00 mov $0x0,%ecx
    715a: ba 04 00 00 00 mov $0x4,%edx
    715f: be 00 c0 00 00 mov $0xc000,%esi
    7164: 48 89 ef mov %rbp,%rdi
    7167: e8 4c de ff ff callq 4fb8 <c_iocb::set_rd(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)@plt>
        return false;
    716c: e9 40 01 00 00 jmpq 72b1 <c_uniline_dlp::echo(c_iocb*)+0x1b3>
    }

    switch (cmd) {

scott