diff options
author | Erlang/OTP <[email protected]> | 2009-11-20 14:54:40 +0000 |
---|---|---|
committer | Erlang/OTP <[email protected]> | 2009-11-20 14:54:40 +0000 |
commit | 84adefa331c4159d432d22840663c38f155cd4c1 (patch) | |
tree | bff9a9c66adda4df2106dfd0e5c053ab182a12bd /erts/emulator/test/alloc_SUITE_data/realloc_copy.c | |
download | otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2 otp-84adefa331c4159d432d22840663c38f155cd4c1.zip |
The R13B03 release.OTP_R13B03
Diffstat (limited to 'erts/emulator/test/alloc_SUITE_data/realloc_copy.c')
-rw-r--r-- | erts/emulator/test/alloc_SUITE_data/realloc_copy.c | 279 |
1 files changed, 279 insertions, 0 deletions
diff --git a/erts/emulator/test/alloc_SUITE_data/realloc_copy.c b/erts/emulator/test/alloc_SUITE_data/realloc_copy.c new file mode 100644 index 0000000000..12454c75e4 --- /dev/null +++ b/erts/emulator/test/alloc_SUITE_data/realloc_copy.c @@ -0,0 +1,279 @@ +/* ``The contents of this file are subject to the Erlang Public License, + * Version 1.1, (the "License"); you may not use this file except in + * compliance with the License. You should have received a copy of the + * Erlang Public License along with this software. If not, it can be + * retrieved via the world wide web at http://www.erlang.org/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and limitations + * under the License. + * + * The Initial Developer of the Original Code is Ericsson Utvecklings AB. + * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings + * AB. All Rights Reserved.'' + * + * $Id$ + */ + +#include "testcase_driver.h" +#include "allocator_test.h" +#include <stdio.h> +#include <string.h> + +#if 1 +#define PRINT_ALLOC_OPS +#endif + +#define SBC_THRESHOLD 8192 +#define NO_OF_BLOCKS 7 +#define NO_OF_ALLOC_OPS_PER_BLOCK 700 + +typedef struct { + unsigned char *p; + Ulong s; + int i; + Ulong *as; +} block; + +Ulong alloc_seq_1[] = { + SBC_THRESHOLD, /* mmap */ + SBC_THRESHOLD*4, /* mmap to new mmap */ + SBC_THRESHOLD/50, /* mmap to malloc */ + SBC_THRESHOLD, /* malloc to mmap */ + 0 +}; + + +Ulong alloc_seq_2[] = { + 1, + SBC_THRESHOLD/10, + SBC_THRESHOLD/9, + SBC_THRESHOLD/8, + SBC_THRESHOLD/7, + SBC_THRESHOLD/6, + SBC_THRESHOLD/5, + SBC_THRESHOLD/4, + SBC_THRESHOLD/3, + SBC_THRESHOLD/2, + SBC_THRESHOLD*1, + SBC_THRESHOLD*2, + SBC_THRESHOLD*3, + SBC_THRESHOLD*4, + SBC_THRESHOLD*5, + SBC_THRESHOLD*6, + SBC_THRESHOLD*7, + SBC_THRESHOLD*8, + SBC_THRESHOLD*9, + SBC_THRESHOLD*10, + SBC_THRESHOLD*9, + SBC_THRESHOLD*8, + SBC_THRESHOLD*7, + SBC_THRESHOLD*6, + SBC_THRESHOLD*5, + SBC_THRESHOLD*4, + SBC_THRESHOLD*3, + SBC_THRESHOLD*2, + SBC_THRESHOLD*1, + SBC_THRESHOLD/2, + SBC_THRESHOLD/3, + SBC_THRESHOLD/4, + SBC_THRESHOLD/5, + SBC_THRESHOLD/6, + SBC_THRESHOLD/7, + SBC_THRESHOLD/8, + SBC_THRESHOLD/9, + SBC_THRESHOLD/10, + 1, + 0 +}; + +Ulong alloc_seq_3[] = { + SBC_THRESHOLD*11, + SBC_THRESHOLD*10, + SBC_THRESHOLD*9, + SBC_THRESHOLD*8, + SBC_THRESHOLD*7, + SBC_THRESHOLD*6, + SBC_THRESHOLD*5, + SBC_THRESHOLD*4, + SBC_THRESHOLD*3, + SBC_THRESHOLD*2, + SBC_THRESHOLD*1, + SBC_THRESHOLD/2, + SBC_THRESHOLD/3, + SBC_THRESHOLD/4, + SBC_THRESHOLD/5, + SBC_THRESHOLD/6, + SBC_THRESHOLD/7, + SBC_THRESHOLD/8, + SBC_THRESHOLD/9, + SBC_THRESHOLD/10, + 1, + SBC_THRESHOLD/10, + SBC_THRESHOLD/9, + SBC_THRESHOLD/8, + SBC_THRESHOLD/7, + SBC_THRESHOLD/6, + SBC_THRESHOLD/5, + SBC_THRESHOLD/4, + SBC_THRESHOLD/3, + SBC_THRESHOLD/2, + SBC_THRESHOLD*1, + SBC_THRESHOLD*2, + SBC_THRESHOLD*3, + SBC_THRESHOLD*4, + SBC_THRESHOLD*5, + SBC_THRESHOLD*6, + SBC_THRESHOLD*7, + SBC_THRESHOLD*8, + SBC_THRESHOLD*9, + SBC_THRESHOLD*10, + 0 +}; + +Ulong alloc_seq_4[] = { + SBC_THRESHOLD*1, + SBC_THRESHOLD*10, + SBC_THRESHOLD*1, + 0 +}; + +Ulong alloc_seq_5[] = { + SBC_THRESHOLD/50, + SBC_THRESHOLD*10, + SBC_THRESHOLD/50, + 0 +}; + +Ulong alloc_seq_6[] = { + SBC_THRESHOLD/50, + SBC_THRESHOLD*10, + SBC_THRESHOLD/50, + SBC_THRESHOLD*10, + 0 +}; + +Ulong alloc_seq_7[] = { + 1, + SBC_THRESHOLD/50, + SBC_THRESHOLD*10, + SBC_THRESHOLD/50, + 0 +}; + + +block blocks[NO_OF_BLOCKS] = {{NULL, 0, 0, alloc_seq_1}, + {NULL, 0, 0, alloc_seq_2}, + {NULL, 0, 0, alloc_seq_3}, + {NULL, 0, 0, alloc_seq_4}, + {NULL, 0, 0, alloc_seq_5}, + {NULL, 0, 0, alloc_seq_6}, + {NULL, 0, 0, alloc_seq_7}}; + +#define CHECK_BLOCK_DATA(T, P, S, D) \ + check_block_data(__FILE__, __LINE__, (T), (P), (S), (D)) + +static void +check_block_data(char *file, int line, + TestCaseState_t *tcs, unsigned char *p, Ulong sz, int d) +{ + Ulong i; + for (i = 0; i < sz; i++) + if (p[i] != (unsigned char) d) + testcase_failed(tcs, "%s:%d: Data clobbered! found id=%d; " + "expected id=%d\n", file, line, (int) p[i], d); +} + + +static void +alloc_op(TestCaseState_t *tcs, Allctr_t *a, block *bp, int id, int clean_up) +{ + if(bp->p) + CHECK_BLOCK_DATA(tcs, bp->p, bp->s, id); + + if(bp->as[bp->i] == 0 || clean_up) { + FREE(a, bp->p); +#ifdef PRINT_ALLOC_OPS + testcase_printf(tcs, "FREE(0x%lx) [id=%d]\n", (Ulong) bp->p, id); +#endif + bp->p = NULL; + bp->s = 0; + bp->i = 0; /* start from the beginning again */ + return; + } + + if(!bp->p) { + bp->s = bp->as[bp->i]; + bp->p = (unsigned char *) ALLOC(a, bp->s); +#ifdef PRINT_ALLOC_OPS + testcase_printf(tcs, "0x%lx = ALLOC(%lu) [id=%d]\n", + (Ulong) bp->p, bp->s, id); +#endif + if(!bp->p) + testcase_failed(tcs, "ALLOC(%lu) failed [id=%d])\n", bp->s, id); + memset((void *) bp->p, id, (size_t) bp->s); + } + else { + unsigned char *p = (unsigned char *) REALLOC(a, bp->p, bp->as[bp->i]); +#ifdef PRINT_ALLOC_OPS + testcase_printf(tcs, "0x%lx = REALLOC(0x%lx, %lu) [id=%d]\n", + (Ulong) p, (Ulong) bp->p, bp->as[bp->i], id); +#endif + if(!p) { + testcase_failed(tcs, "REALLOC(0x%lx, %lu) failed [id=%d]\n", + (Ulong) bp->p, bp->as[bp->i], id); + } + + if(bp->s < bp->as[bp->i]) { + CHECK_BLOCK_DATA(tcs, p, bp->s, id); + memset((void *) p, id, (size_t) bp->as[bp->i]); + } + else + CHECK_BLOCK_DATA(tcs, p, bp->as[bp->i], id); + + bp->s = bp->as[bp->i]; + bp->p = p; + } + + bp->i++; +} + +char * +testcase_name(void) +{ + return "realloc_copy"; +} + +void +testcase_run(TestCaseState_t *tcs) +{ + int i, j; + char sbct_buf[20]; + char *argv[] = {"-tmmsbc", "5000", "-tsbct", &sbct_buf[0], NULL}; + Allctr_t *a; + + sprintf(sbct_buf, "%d", SBC_THRESHOLD/1024); + + a = START_ALC("realloc_copy_", 0, argv); + ASSERT(tcs, a); + tcs->extra = (void *) a; + + for(i = 0; i < NO_OF_ALLOC_OPS_PER_BLOCK; i++) + for(j = 0; j < NO_OF_BLOCKS; j++) + alloc_op(tcs, a, &blocks[j], j + 1, 0); + + for(j = 0; j < NO_OF_BLOCKS; j++) + alloc_op(tcs, a, &blocks[j], j + 1, 1); + + STOP_ALC((Allctr_t *) tcs->extra); + tcs->extra = NULL; +} + +void +testcase_cleanup(TestCaseState_t *tcs) +{ + if (tcs->extra) + STOP_ALC((Allctr_t *) tcs->extra); +} + |