Attachment 181258 Details for Bug 217138 – Test program with thousands of 14 KiByte allocations

Test program with thousands of 14 KiByte allocations

file_217138.txt (text/plain), 4.77 KB, created by Mark Millard on 2017-03-28 03:43:41 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Mark Millard

Created: 2017-03-28 03:43:41 UTC

Size: 4.77 KB

patch

obsolete

>// swap_testing2.c
>
>// Built via (c++ was clang++ 4.0 in my case):
>//
>// cc -g -std=c11 -Wpedantic -o swaptesting2 swap_testing2.c
>// -O0 and -O2 also gets the problem.
>
>#include <unistd.h>     // for fork(), sleep(.)
>#include <sys/types.h>  // for pid_t
>#include <sys/wait.h>   // for wait(.)
>
>#include <signal.h>     // for raise(.), SIGABRT
>
>extern void test_setup(void);         // Sets up the memory byte patterns.
>extern void test_check(void);         // Tests the memory byte patterns.
>extern void partial_test_check(void); // Tests just [0] of dyn_regions[0]
>
>int main(void) {
>    test_setup();
>    test_check(); // Before fork() [passes]
>
>    pid_t pid = fork();
>    int wait_status = 0;;
>
>    // After fork; before waitsleep/swap-out.
>
>    //if (0==pid) partial_test_check();
>                     // Even the above is sufficient by
>                     // itself to prevent failure for
>                     // region_size 1u through
>                     // 4u*1024u!
>                     // But 4u*1024u+1u and above fail
>                     // with this access to memory.
>                     // The failing test is of
>                     // (*dyn_regions[0]).array[4096u].
>                     // This test never fails here.
>
>    if (0<pid) partial_test_check(); // This never prevents
>                                     // later failures (and
>                                     // never fails here).
>
>    if (0<pid) { wait(&wait_status); }
>
>    if (-1!=wait_status && 0<=pid) {
>        if (0==pid) {
>            sleep(60);
>
>            // During this manually force this process to
>            // swap out. I use something like:
>
>            // stress -m 1 --vm-bytes 1800M
>
>            // in another shell and ^C'ing it after top
>            // shows the swapped status desired. 1800M
>            // just happened to work on the Pine64+ 2GB
>            // that I was using. I watch with top -PCwaopid .
>        }
>
>        test_check(); // After wait/sleep [fails for small-enough region_sizes]
>
>        // raise(SIGABRT);
>    }
>}
>
>// The memory and test code follows.
>
>#include <stddef.h>     // for size_t, NULL
>#include <stdlib.h>     // for malloc(.), free(.)
>
>#define region_size (14u*1024u)
>                        // Bad dyn_regions patterns, parent and child
>                        // processes:
>                        //     256u,  2u*1024u,  4u*1024u, 8u*1024u,
>                        // 9u*1024u, 12u*1024u, 14u*1024u
>                        // (but see the partial_test_check() call
>                        //  notes above).
>
>                        // Works:
>                        // 14u*1024u+1u, 15u*1024u, 16u*1024u,
>                        // 32u*1024u, 256u*1024u*1024u
>#define num_regions (256u*1024u*1024u/region_size)
>
>typedef volatile unsigned char value_type;
>
>struct region_struct { value_type array[region_size]; };
>typedef struct region_struct region;
>
>static region * volatile dyn_regions[num_regions] = {NULL,};
>
>static value_type value(size_t v) { return (value_type)((v&0xFEu)|0x1u); }
>                  // value now avoids the zero value since the failures
>                  // are zeros.
>
>void test_setup(void) {
>    for(size_t i=0u; i<num_regions; i++) {
>        dyn_regions[i] = malloc(sizeof(region));
>        if (!dyn_regions[i]) raise(SIGABRT);
>
>        for(size_t j=0u; j<region_size; j++) {
>            (*dyn_regions[i]).array[j] = value(j);
>        }
>    }
>}
>
>void partial_test_check(void) {
>    if (value(0u)!=(*dyn_regions[0u]).array[0]) raise(SIGABRT);
>}
>
>static volatile size_t first_failure_idx = 0u;
>static volatile size_t first_failure_pos = 0u;
>static volatile size_t after_bad_idx   = 0u;
>static volatile size_t after_bad_pos   = 0u;
>
>void test_check(void) {
>    first_failure_idx = first_failure_pos = 0u;
>    while (first_failure_idx < num_regions) {
>        while (  first_failure_pos < region_size
>              && (  value(first_failure_pos)
>                 == (*dyn_regions[first_failure_idx]).array[first_failure_pos]
>                 )
>              ) {
>            first_failure_pos++;
>        }
>
>        if (region_size != first_failure_pos) break;
>
>        first_failure_idx++;
>        first_failure_pos = 0u;
>    }
>
>    if (num_regions == first_failure_idx) return;
>
>    after_bad_idx = first_failure_idx;
>    after_bad_pos = first_failure_pos;
>
>    while (after_bad_idx < num_regions) {
>        while (  after_bad_pos < region_size
>              && (  value(after_bad_pos)
>                 != (*dyn_regions[after_bad_idx]).array[after_bad_pos]
>                 )
>              ) {
>            after_bad_pos++;
>        }
>
>        if(region_size != after_bad_pos) break;
>
>        after_bad_idx++;
>        after_bad_pos = 0u;
>    }
>
>    raise(SIGABRT);
>}

Actions: View

Attachments on bug 217138: 180808 | 180836 | 181044 | 181258 | 181498