ram_reply_t rammux_acquire(void **newptr_arg, rammux_pool_t *mpool_arg, size_t size_arg)
{
ramalgn_pool_t *apool = NULL;
ram_reply_t e = RAM_REPLY_INSANE;
RAM_FAIL_NOTNULL(newptr_arg);
*newptr_arg = NULL;
RAM_FAIL_NOTNULL(mpool_arg);
RAM_FAIL_NOTZERO(size_arg);
e = rammux_getalgnpool(&apool, size_arg, mpool_arg);
switch (e)
{
default:
RAM_FAIL_TRAP(e);
/* i shouldn't ever get here. */
return RAM_REPLY_INSANE;
case RAM_REPLY_RANGEFAIL:
return e;
case RAM_REPLY_OK:
break;
}
RAM_FAIL_TRAP(ramalgn_acquire(newptr_arg, apool));
return RAM_REPLY_OK;
}
ram_reply_t ramtest_fill(char *ptr_arg, size_t sz_arg)
{
RAM_FAIL_NOTNULL(ptr_arg);
RAM_FAIL_NOTZERO(sz_arg);
memset(ptr_arg, (int)(sz_arg & 0xff), sz_arg);
return RAM_REPLY_OK;
}
ram_reply_t ramvec_mkpool2(ramvec_pool_t *pool_arg, size_t nodecap_arg,
ramvec_mknode_t mknode_arg)
{
assert(pool_arg != NULL);
RAM_FAIL_NOTZERO(nodecap_arg);
RAM_FAIL_NOTNULL(mknode_arg);
RAM_FAIL_TRAP(ramlist_mklist(&pool_arg->ramvecvp_inv));
RAM_FAIL_TRAP(ramlist_mklist(&pool_arg->ramvecvp_avail));
pool_arg->ramvecvp_nodecapacity = nodecap_arg;
pool_arg->ramvecvp_mknode = mknode_arg;
return RAM_REPLY_OK;
}
ram_reply_t ramlin_mkbarrier(ramlin_barrier_t *barrier_arg,
size_t capacity_arg)
{
RAM_FAIL_NOTNULL(barrier_arg);
RAM_FAIL_NOTZERO(capacity_arg);
barrier_arg->ramlinb_capacity = capacity_arg;
barrier_arg->ramlinb_vacancy = capacity_arg;
barrier_arg->ramlinb_cycle = 0;
RAM_FAIL_TRAP(ramuix_mkmutex(&barrier_arg->ramlinb_mutex));
RAM_FAIL_EXPECT(RAM_REPLY_APIFAIL,
0 == pthread_cond_init(&barrier_arg->ramlinb_cond, NULL));
return RAM_REPLY_OK;
}
ram_reply_t ramtest_chkfill(char *ptr_arg, size_t sz_arg)
{
char *p = NULL, *z = NULL;
RAM_FAIL_NOTNULL(ptr_arg);
RAM_FAIL_NOTZERO(sz_arg);
for (p = ptr_arg, z = ptr_arg + sz_arg;
p < z && ((char)(sz_arg & 0xff)) == *p; ++p)
continue;
if (p != z)
return RAM_REPLY_CORRUPT;
return RAM_REPLY_OK;
}
ram_reply_t acquire(ramtest_allocdesc_t *desc_arg,
size_t size_arg, void *extra_arg, size_t threadidx_arg)
{
void *p = NULL;
RAM_FAIL_NOTNULL(desc_arg);
memset(desc_arg, 0, sizeof(*desc_arg));
RAM_FAIL_NOTZERO(size_arg);
RAMANNOTATE_UNUSEDARG(extra_arg);
RAMANNOTATE_UNUSEDARG(threadidx_arg);
RAM_FAIL_TRAP(ram_default_acquire(&p, size_arg));
desc_arg->ramtestad_ptr = (char *)p;
/* the default module doesn't use explicit pool instances. i only need
* to note whether i'm using the pool or not. i shall use the value of
* 1 to indicate this. */
desc_arg->ramtestad_pool = (void *)1;
desc_arg->ramtestad_sz = size_arg;
return RAM_REPLY_OK;
}
ram_reply_t rammux_getalgnpool(ramalgn_pool_t **apool_arg, size_t size_arg, rammux_pool_t *mpool_arg)
{
size_t idx = 0;
RAM_FAIL_NOTNULL(apool_arg);
*apool_arg = NULL;
RAM_FAIL_NOTZERO(size_arg);
RAM_FAIL_NOTNULL(mpool_arg);
idx = (size_arg + mpool_arg->rammuxp_step - 1) / mpool_arg->rammuxp_step - 1;
/* if i can't accomidate the size of the pool, i need to inform the caller. */
if (idx >= RAMMUX_MAXPOOLCOUNT)
return RAM_REPLY_RANGEFAIL;
if (!mpool_arg->rammuxp_initflags[idx])
{
ram_reply_t e = RAM_REPLY_INSANE;
e = ramalgn_mkpool(&mpool_arg->rammuxp_apools[idx], mpool_arg->rammuxp_appetite, mpool_arg->rammuxp_step * (idx + 1), &mpool_arg->rammuxp_tag);
switch (e)
{
default:
RAM_FAIL_TRAP(e);
/* i shouldn't ever get here. */
return RAM_REPLY_INSANE;
case RAM_REPLY_RANGEFAIL:
return e;
case RAM_REPLY_OK:
break;
}
assert(mpool_arg->rammuxp_apools[idx].ramalgnp_slotpool.ramslotp_granularity >= size_arg);
assert(mpool_arg->rammuxp_apools[idx].ramalgnp_slotpool.ramslotp_granularity - size_arg < mpool_arg->rammuxp_step);
mpool_arg->rammuxp_initflags[idx] = 1;
}
*apool_arg = &mpool_arg->rammuxp_apools[idx];
return RAM_REPLY_OK;
}
ram_reply_t ramtest_shuffle(void *array_arg, size_t size_arg,
size_t count_arg)
{
char *p = (char *)array_arg;
size_t i = 0;
RAM_FAIL_NOTNULL(array_arg);
RAM_FAIL_NOTZERO(size_arg);
if (0 < count_arg)
{
for (i = count_arg - 1; i > 0; --i)
{
uint32_t j = 0;
RAM_FAIL_TRAP(ramtest_randuint32(&j, 0, i));
RAM_FAIL_TRAP(rammisc_swap(&p[i * size_arg], &p[j * size_arg],
size_arg));
}
}
return RAM_REPLY_OK;
}
ram_reply_t ramwin_basename2(char *dest_arg, size_t len_arg,
const char *pathn_arg)
{
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char filen[_MAX_FNAME];
char ext[_MAX_EXT];
errno_t e = -1;
int n = -1;
RAM_FAIL_NOTNULL(dest_arg);
RAM_FAIL_NOTZERO(len_arg);
RAM_FAIL_NOTNULL(pathn_arg);
/* first, i use _splitpath_s() to get the components. */
e = _splitpath_s(pathn_arg, drive, _MAX_DRIVE, dir, _MAX_DIR, filen,
_MAX_FNAME, ext, _MAX_EXT);
RAM_FAIL_EXPECT(RAM_REPLY_APIFAIL, 0 == e);
/* now, i need to reassemble them into the equivalent of a basename. */
n = _snprintf_s(dest_arg, len_arg,
_MAX_FNAME + _MAX_EXT, "%s%s", filen, ext);
RAM_FAIL_EXPECT(RAM_REPLY_APIFAIL, -1 < n);
return RAM_REPLY_OK;
}
ram_reply_t ramtest_inittest2(ramtest_test_t *test_arg,
const ramtest_params_t *params_arg)
{
size_t i = 0;
size_t seqlen = 0;
size_t maxthreads = 0;
size_t unused = 0;
RAM_FAIL_NOTNULL(params_arg);
RAM_FAIL_NOTZERO(params_arg->ramtestp_alloccount);
RAM_FAIL_EXPECT(RAM_REPLY_RANGEFAIL, params_arg->ramtestp_minsize > 0);
RAM_FAIL_EXPECT(RAM_REPLY_RANGEFAIL,
params_arg->ramtestp_minsize <= params_arg->ramtestp_maxsize);
RAM_FAIL_EXPECT(RAM_REPLY_RANGEFAIL, params_arg->ramtestp_mallocchance >= 0);
RAM_FAIL_EXPECT(RAM_REPLY_RANGEFAIL, params_arg->ramtestp_mallocchance <= 100);
RAM_FAIL_NOTNULL(params_arg->ramtestp_acquire);
RAM_FAIL_NOTNULL(params_arg->ramtestp_release);
RAM_FAIL_NOTNULL(params_arg->ramtestp_query);
/* *params_arg->ramtestp_flush* is allowed to be NULL. */
RAM_FAIL_NOTNULL(params_arg->ramtestp_check);
RAM_FAIL_TRAP(ramtest_maxthreadcount(&maxthreads));
RAM_FAIL_EXPECT(RAM_REPLY_DISALLOWED,
params_arg->ramtestp_threadcount <= maxthreads);
test_arg->ramtestt_params = *params_arg;
if (0 == test_arg->ramtestt_params.ramtestp_threadcount)
{
RAM_FAIL_TRAP(ramtest_defaultthreadcount(
&test_arg->ramtestt_params.ramtestp_threadcount));
}
test_arg->ramtestt_records =
calloc(test_arg->ramtestt_params.ramtestp_alloccount,
sizeof(*test_arg->ramtestt_records));
RAM_FAIL_EXPECT(RAM_REPLY_RESOURCEFAIL,
NULL != test_arg->ramtestt_records);
test_arg->ramtestt_threads =
calloc(test_arg->ramtestt_params.ramtestp_threadcount,
sizeof(*test_arg->ramtestt_threads));
RAM_FAIL_EXPECT(RAM_REPLY_RESOURCEFAIL,
NULL != test_arg->ramtestt_threads);
seqlen = test_arg->ramtestt_params.ramtestp_alloccount * 2;
test_arg->ramtestt_sequence = calloc(seqlen,
sizeof(*test_arg->ramtestt_sequence));
RAM_FAIL_EXPECT(RAM_REPLY_RESOURCEFAIL,
NULL != test_arg->ramtestt_sequence);
RAM_FAIL_TRAP(rammtx_mkmutex(&test_arg->ramtestt_mtx));
for (i = 0; i < test_arg->ramtestt_params.ramtestp_alloccount; ++i)
{
RAM_FAIL_TRAP(rammtx_mkmutex(
&test_arg->ramtestt_records[i].ramtestar_mtx));
}
/* the sequence array must contain two copies of each index into
* *test_arg->ramtestt_records*. the first represents an allocation.
* the second, a deallocation. */
for (i = 0; i < seqlen; ++i)
test_arg->ramtestt_sequence[i] = (i / 2);
/* i shuffle the sequence array to ensure a randomized order of
* operations. */
RAM_FAIL_TRAP(ramtest_shuffle(test_arg->ramtestt_sequence,
sizeof(test_arg->ramtestt_sequence[0]), seqlen));
if (!test_arg->ramtestt_params.ramtestp_userngseed)
test_arg->ramtestt_params.ramtestp_rngseed = (unsigned int)time(NULL);
srand(test_arg->ramtestt_params.ramtestp_rngseed);
RAM_FAIL_TRAP(ramtest_fprintf(&unused, stderr,
"[0] i seeded the random generator with the value %u.\n",
test_arg->ramtestt_params.ramtestp_rngseed));
test_arg->ramtestt_nextrec = 0;
return RAM_REPLY_OK;
}
