/* ``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);
}
