/* ``Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions 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$
*/
#ifndef __WIN32__
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#endif
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "testcase_driver.h"
#include "allocator_test.h"
#ifdef __WIN32__
#undef HAVE_VSNPRINTF
#define HAVE_VSNPRINTF 1
#define vsnprintf _vsnprintf
#endif
#ifndef HAVE_VSNPRINTF
#define HAVE_VSNPRINTF 0
#endif
#define NO_OF_ALLOC_SEQS 6
#define NO_OF_THREADS (18)
#define NO_OF_BLOCKS 10
#define NO_OF_OPS_PER_BL 200
#define SBC_THRESHOLD 8192
#define BLOCK_ID(TN, BN) ((TN) << 4 | (BN))
#define ERR_BUF_SZ 4096
static char err_buf[ERR_BUF_SZ];
static volatile int tc_failed;
static int dead_thread_no;
static erts_mutex tc_mutex;
static erts_cond tc_cond;
static void exit_thread(int t_no, int do_lock)
{
if (do_lock)
THR_MTX_LOCK(tc_mutex);
while (dead_thread_no >= 0)
THR_COND_WAIT(tc_cond, tc_mutex);
dead_thread_no = t_no;
THR_COND_BCAST(tc_cond);
THR_MTX_UNLOCK(tc_mutex);
THR_EXIT(NULL);
}
static void fail(int t_no, char *frmt, ...)
{
char buf[10];
size_t bufsz = sizeof(buf);
va_list va;
THR_MTX_LOCK(tc_mutex);
va_start(va, frmt);
#if HAVE_VSNPRINTF
vsnprintf(err_buf, ERR_BUF_SZ, frmt, va);
#else
vsprintf(err_buf, frmt, va);
#endif
va_end(va);
tc_failed = 1;
if (enif_getenv("ERL_ABORT_ON_FAILURE", buf, &bufsz) == 0
&& strcmp("true", buf) == 0) {
fprintf(stderr, "Testcase \"%s\" failed: %s\n",
testcase_name(), err_buf);
abort();
}
exit_thread(t_no, 0);
}
static Allctr_t *alloc_ts_1 = NULL;
static Allctr_t *alloc_ts_2 = NULL;
static void stop_allocators(void)
{
if (alloc_ts_1) {
STOP_ALC(alloc_ts_1);
alloc_ts_1 = NULL;
}
if (alloc_ts_2) {
STOP_ALC(alloc_ts_2);
alloc_ts_2 = NULL;
}
}
void *thread_func(void *arg);
typedef struct {
Allctr_t *a;
int t_no;
int no_ops_per_bl;
} ThreadData;
char *
testcase_name(void)
{
return "threads";
}
void
testcase_cleanup(TestCaseState_t *tcs)
{
stop_allocators();
}
void
testcase_run(TestCaseState_t *tcs)
{
struct {
erts_thread tid;
ThreadData arg;
} threads[NO_OF_THREADS+1] = {{0}};
int no_threads;
int i;
char sbct_buf[10];
char *argv_org[] = {"-tasaobf", "-tmmsbc5000", "-tmmmbc5000", "-tsbct",
&sbct_buf[0], NULL};
char *argv[sizeof(argv_org)/sizeof(argv_org[0])];
if (!IS_THREADS_ENABLED)
testcase_skipped(tcs, "Threads not enabled");
alloc_ts_1 = NULL;
alloc_ts_2 = NULL;
err_buf[0] = '\0';
sprintf(sbct_buf, "%d", SBC_THRESHOLD/1024);
memcpy((void *) argv, argv_org, sizeof(argv_org));
alloc_ts_1 = START_ALC("threads_ts_1", 1, argv);
ASSERT(tcs, alloc_ts_1);
memcpy((void *) argv, argv_org, sizeof(argv_org));
alloc_ts_2 = START_ALC("threads_ts_2", 1, argv);
ASSERT(tcs, alloc_ts_2);
ASSERT(tcs, IS_ALLOC_THREAD_SAFE(alloc_ts_1));
ASSERT(tcs, IS_ALLOC_THREAD_SAFE(alloc_ts_2));
tc_mutex = THR_MTX_CREATE();
tc_cond = THR_COND_CREATE();
THR_MTX_LOCK(tc_mutex);
dead_thread_no = -1;
no_threads = 0;
for(i = 1; i <= NO_OF_THREADS; i++) {
char *alc;
threads[i].arg.no_ops_per_bl = NO_OF_OPS_PER_BL;
if (i % 2 == 0) {
alc = "threads_ts_1";
threads[i].arg.a = alloc_ts_1;
}
else {
alc = "threads_ts_2";
threads[i].arg.a = alloc_ts_2;
}
threads[i].arg.t_no = i;
threads[i].tid = THR_CREATE(thread_func, (void *) &threads[i].arg);
if (threads[i].tid) {
testcase_printf(tcs, "Successfully created thread %d "
"using %s_alloc\n", i, alc);
no_threads++;
}
else {
tc_failed = 1;
sprintf(err_buf, "Failed to create thread %d\n", i);
break;
}
}
while (no_threads) {
THR_COND_WAIT(tc_cond, tc_mutex);
if (dead_thread_no >= 0) {
no_threads--;
THR_JOIN(threads[dead_thread_no].tid);
testcase_printf(tcs, "Thread %d died\n", dead_thread_no);
dead_thread_no = -1;
THR_COND_BCAST(tc_cond);
}
}
THR_MTX_UNLOCK(tc_mutex);
THR_MTX_DESTROY(tc_mutex);
THR_COND_DESTROY(tc_cond);
stop_allocators();
if (tc_failed)
testcase_failed(tcs, "%s", err_buf);
}
Ulong alloc_seq_1[] = {
17,
SBC_THRESHOLD*2,
SBC_THRESHOLD*20,
SBC_THRESHOLD*2,
17,
0
};
Ulong alloc_seq_2[] = {
SBC_THRESHOLD*20,
SBC_THRESHOLD*2,
17,
SBC_THRESHOLD*2,
SBC_THRESHOLD*20,
0
};
Ulong alloc_seq_3[] = {
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*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_4[] = {
SBC_THRESHOLD*2,
SBC_THRESHOLD*3,
SBC_THRESHOLD*7,
SBC_THRESHOLD*8,
SBC_THRESHOLD*5,
SBC_THRESHOLD*6,
SBC_THRESHOLD*1,
SBC_THRESHOLD*10,
SBC_THRESHOLD*4,
SBC_THRESHOLD*2,
0
};
Ulong alloc_seq_5[] = {
SBC_THRESHOLD/2,
SBC_THRESHOLD/3,
SBC_THRESHOLD/7,
SBC_THRESHOLD/8,
SBC_THRESHOLD/5,
SBC_THRESHOLD/6,
SBC_THRESHOLD/1,
SBC_THRESHOLD/10,
SBC_THRESHOLD/4,
SBC_THRESHOLD/2,
SBC_THRESHOLD/3,
SBC_THRESHOLD/7,
SBC_THRESHOLD/8,
SBC_THRESHOLD/5,
SBC_THRESHOLD/6,
SBC_THRESHOLD/1,
SBC_THRESHOLD/10,
SBC_THRESHOLD/4,
SBC_THRESHOLD/2,
0
};
Ulong alloc_seq_6[] = {
1, 50, 100, 50, 23, 46, 2345, 23, 54, 2, 0
};
Ulong *alloc_seqs[NO_OF_ALLOC_SEQS] = {
alloc_seq_1,
alloc_seq_2,
alloc_seq_3,
alloc_seq_4,
alloc_seq_5,
alloc_seq_6
};
typedef struct {
unsigned char *p;
Ulong s;
int i;
Ulong *as;
} block;
#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, int t_no,
unsigned char *p, Ulong sz, int d)
{
Ulong i;
for (i = 0; i < sz; i++)
if (p[i] != (unsigned char) d)
fail(t_no, "%s:%d: Thread no %d found clobbered data! "
"found id=%d; expected id=%d\n",
file, line, t_no, (int) p[i], d);
}
static void
alloc_op(int t_no, Allctr_t *a, block *bp, int id, int clean_up)
{
if (tc_failed)
exit_thread(t_no, 1);
if(bp->p)
CHECK_BLOCK_DATA(t_no, bp->p, bp->s, id);
if(bp->as[bp->i] == 0 || clean_up) {
FREE(a, bp->p);
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);
if(!bp->p)
fail(t_no, "ALLOC(%lu) failed [id=%d])\n", bp->s, id);
memset((void *) bp->p, (unsigned char)id, (size_t) bp->s);
}
else {
unsigned char *p = (unsigned char *) REALLOC(a, bp->p, bp->as[bp->i]);
if(!p)
fail(t_no, "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(t_no, p, bp->s, id);
memset((void *) p, (unsigned char)id, (size_t) bp->as[bp->i]);
}
else
CHECK_BLOCK_DATA(t_no, p, bp->as[bp->i], id);
bp->s = bp->as[bp->i];
bp->p = p;
}
bp->i++;
}
void *
thread_func(void *arg)
{
int i, j;
ThreadData *td = ((ThreadData *) arg);
block bs[NO_OF_BLOCKS];
for(i = 0; i < NO_OF_BLOCKS; i++) {
bs[i].p = NULL;
bs[i].s = 0;
bs[i].i = 0;
bs[i].as = alloc_seqs[i % NO_OF_ALLOC_SEQS];
}
for(i = 0; i < td->no_ops_per_bl; i++) {
for(j = 0; j < NO_OF_BLOCKS; j++)
alloc_op(td->t_no, td->a, &bs[j], BLOCK_ID(td->t_no, j), 0);
}
for(j = 0; j < NO_OF_BLOCKS; j++)
alloc_op(td->t_no, td->a, &bs[j], BLOCK_ID(td->t_no, j), 1);
exit_thread(td->t_no, 1);
return NULL;
}
ERL_NIF_INIT(threads, testcase_nif_funcs, testcase_nif_init,
NULL, NULL, NULL);
