Allocation failure testing -- results report (babb) Survey

1.What is a short name or label to describe the program you tested? If the program's name is confidential, please use a short descriptive label instead (e.g., "Unreal game").

2.Before doing this test, what was your expectation about how well the program handled allocation failures?

My program was not expected to handle allocation failures at all, it exits immediately and at most it installed a new_handler and/or terminate_handler

Some parts of my program were carefully written to be safe for allocation failures

My program was written to be exception-safe and to use exceptions to report allocation failures, and so was expected to able to robustly handle allocation failure like any other exception

3.Which of the following style of allocation failure reporting are used in the program? (select all that apply)

Throwing std::bad_alloc

Throwing another kind of exception (e.g., an in-house custom exception)

Returning null (e.g., by using new(nothrow))

4.Approximately how many test executions did you try?

1-5

6-10

11-20

More than 20

5.Did your program crash, meaning to terminate in any way that was not intended?

Never crashed

Crashed rarely, <5% test executions

Crashed sometimes

Crashed consistently, >90% of test executions

If applicable, please describe what fail_once_per and max_run_length settings would cause crashes most frequently and least frequently

6.If failures to handle allocation failures well were observed, which code did the problems arise in? (check all that apply, as known)

My application's code

Third-party library code

Operating system calls

Mysterious/unknown

If you checked third-party code or OS calls, please describe which library/OS, and examples of function names that failed (if known and if you can share them)

7.If any of the results caused you to investigate your code, did you find code that was allocation failure-unsafe that you did not know was unsafe? (select all that apply)

I found general code paths that were not robust when a allocation failure occurred

I found code paths that specifically existed in case of allocation failure (to handle it, or just to unwind safely), but did not actually work correctly if allocation failure occurred

Please briefly describe your findings.

8.How would you summarize to a colleague "what happened when I tried injecting allocation failures in this program"? Please mention any patterns or any other observations we should know about that were not already covered above.

11.If you selected Linux, what memory allocation settings were you using?

Enabled

Disabled

Tested with both "enabled" and "disabled" on different executions

Used the system default and/or don't know

System-wide: Was overcommit_memory enabled (0 or 1)?

Enabled

Disabled

Tested with both "enabled" and "disabled" on different executions

Used the system default and/or don't know

For this user/program: Was a memory limit enabled (e.g., via ulimit)?

Enabled

Disabled

Tested with both "enabled" and "disabled" on different executions

Used the system default and/or don't know

12.After doing this test, what is your impression about how well the program handled allocation failures?

My program did not handle allocation failures well

Some parts of my program were safe for allocation failures, and these parts typically required careful coding

Some parts of my program were safe for allocation failures, and did not require especially careful coding

My program robustly handled allocation failures

13.(optional) If you would allow a C++ standards committee member to follow up with further questions about your experience, please provide your preferred email address here: