void
sc_package_rc_count_add (int package_id, int toadd)
{
int *pcount;
#ifdef SC_ENABLE_DEBUG
int newvalue;
#endif
if (package_id == -1) {
pcount = &default_rc_active;
}
else {
SC_ASSERT (sc_package_is_registered (package_id));
pcount = &sc_packages[package_id].rc_active;
}
sc_package_lock (package_id);
#ifdef SC_ENABLE_DEBUG
newvalue =
#endif
*pcount += toadd;
sc_package_unlock (package_id);
SC_ASSERT (newvalue >= 0);
}
int
sc_allgather (void *sendbuf, int sendcount, sc_MPI_Datatype sendtype,
void *recvbuf, int recvcount, sc_MPI_Datatype recvtype,
sc_MPI_Comm mpicomm)
{
int mpiret;
int mpisize;
int mpirank;
size_t datasize;
#ifdef SC_DEBUG
size_t datasize2;
#endif
SC_ASSERT (sendcount >= 0 && recvcount >= 0);
/* *INDENT-OFF* HORRIBLE indent bug */
datasize = (size_t) sendcount * sc_mpi_sizeof (sendtype);
#ifdef SC_DEBUG
datasize2 = (size_t) recvcount * sc_mpi_sizeof (recvtype);
#endif
/* *INDENT-ON* */
SC_ASSERT (datasize == datasize2);
mpiret = sc_MPI_Comm_size (mpicomm, &mpisize);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_rank (mpicomm, &mpirank);
SC_CHECK_MPI (mpiret);
memcpy (((char *) recvbuf) + mpirank * datasize, sendbuf, datasize);
sc_allgather_recursive (mpicomm, (char *) recvbuf, (int) datasize,
mpisize, mpirank, mpirank);
return sc_MPI_SUCCESS;
}
sc_keyvalue_entry_type_t
sc_keyvalue_unset (sc_keyvalue_t * kv, const char *key)
{
void *found;
sc_keyvalue_entry_t svalue, *pvalue = &svalue;
sc_keyvalue_entry_t *value;
int remove_test;
sc_keyvalue_entry_type_t type;
SC_ASSERT (kv != NULL);
SC_ASSERT (key != NULL);
pvalue->key = key;
pvalue->type = SC_KEYVALUE_ENTRY_NONE;
/* Remove this entry */
remove_test = sc_hash_remove (kv->hash, pvalue, &found);
/* Check whether anything was removed */
if (!remove_test)
return SC_KEYVALUE_ENTRY_NONE;
/* Code reaching this point must have found something */
SC_ASSERT (remove_test);
SC_ASSERT (found != NULL);
value = (sc_keyvalue_entry_t *) found;
type = value->type;
/* destroy the orignial hash entry */
sc_mempool_free (kv->value_allocator, value);
return type;
}
sc_object_t *
boat_klass_new (sc_object_t * d)
{
int a1, a2, a3, a4, a5;
sc_object_t *o;
SC_ASSERT (d != NULL);
SC_ASSERT (sc_object_is_type (d, sc_object_type));
o = sc_object_alloc ();
sc_object_delegate_push (o, d);
a1 = sc_object_method_register (o, (sc_object_method_t) sc_object_is_type,
(sc_object_method_t) is_type_fn);
a2 = sc_object_method_register (o, (sc_object_method_t) sc_object_copy,
(sc_object_method_t) copy_fn);
a3 =
sc_object_method_register (o, (sc_object_method_t) sc_object_initialize,
(sc_object_method_t) initialize_fn);
a4 =
sc_object_method_register (o, (sc_object_method_t) sc_object_write,
(sc_object_method_t) write_fn);
a5 =
sc_object_method_register (o, (sc_object_method_t) vehicle_accelerate,
(sc_object_method_t) accelerate_fn);
SC_ASSERT (a1 && a2 && a3 && a4 && a5);
sc_object_initialize (o, NULL);
return o;
}
void
sc_keyvalue_set_pointer (sc_keyvalue_t * kv, const char *key, void *newvalue)
{
void **found;
sc_keyvalue_entry_t svalue, *pvalue = &svalue;
sc_keyvalue_entry_t *value;
SC_ASSERT (kv != NULL);
SC_ASSERT (key != NULL);
pvalue->key = key;
pvalue->type = SC_KEYVALUE_ENTRY_NONE;
if (sc_hash_lookup (kv->hash, pvalue, &found)) {
/* Key already exists in hash table */
value = (sc_keyvalue_entry_t *) (*found);
SC_ASSERT (value->type == SC_KEYVALUE_ENTRY_POINTER);
value->value.p = (void *) newvalue;
}
else {
/* Key does not exist and must be created */
value = (sc_keyvalue_entry_t *) sc_mempool_alloc (kv->value_allocator);
value->key = key;
value->type = SC_KEYVALUE_ENTRY_POINTER;
value->value.p = (void *) newvalue;
/* Insert value into the hash table */
SC_EXECUTE_ASSERT_TRUE (sc_hash_insert_unique (kv->hash, value, &found));
}
}
int
sc_keyvalue_get_int_check (sc_keyvalue_t * kv, const char *key, int *status)
{
int result;
int etype;
void **found;
sc_keyvalue_entry_t svalue, *pvalue = &svalue;
sc_keyvalue_entry_t *value;
SC_ASSERT (kv != NULL);
SC_ASSERT (key != NULL);
result = (status != NULL) ? *status : INT_MIN;
etype = 1;
pvalue->key = key;
pvalue->type = SC_KEYVALUE_ENTRY_NONE;
if (sc_hash_lookup (kv->hash, pvalue, &found)) {
value = (sc_keyvalue_entry_t *) (*found);
if (value->type == SC_KEYVALUE_ENTRY_INT) {
etype = 0;
result = value->value.i;
}
else {
etype = 2;
}
}
SC_ASSERT (status != NULL || etype == 0);
if (status != NULL) {
*status = etype;
}
return result;
}
void
sc_bspline_derivative_n (sc_bspline_t * bs, int order,
double t, double *result)
{
int i, k, n;
int iguess;
int toffset;
double *wfrom, *wto;
const double *knotse = bs->knots->e[0];
SC_ASSERT (order >= 0);
if (bs->n < order) {
memset (result, 0, sizeof (double) * bs->d);
return;
}
iguess = sc_bspline_find_interval (bs, t);
toffset = 0;
wfrom = wto = bs->points->e[iguess - bs->n];
for (n = bs->n; n > 0; --n) {
wto = bs->works->e[toffset];
if (bs->n < n + order) {
for (i = 0; i < n; ++i) {
const double tleft = knotse[iguess + i - n + 1];
const double tright = knotse[iguess + i + 1];
const double tfactor = n / (tright - tleft);
for (k = 0; k < bs->d; ++k) {
wto[bs->d * i + k] =
(wfrom[bs->d * (i + 1) + k] - wfrom[bs->d * i + k]) * tfactor;
}
}
}
else {
for (i = 0; i < n; ++i) {
const double tleft = knotse[iguess + i - n + 1];
const double tright = knotse[iguess + i + 1];
const double tfactor = 1. / (tright - tleft);
for (k = 0; k < bs->d; ++k) {
wto[bs->d * i + k] =
((t - tleft) * wfrom[bs->d * (i + 1) + k] +
(tright - t) * wfrom[bs->d * i + k]) * tfactor;
}
}
}
wfrom = wto;
toffset += n;
}
SC_ASSERT (toffset == bs->n * (bs->n + 1) / 2);
memcpy (result, wfrom, sizeof (double) * bs->d);
}
static void
sc_free_aligned (void *ptr, size_t alignment)
{
/* minimum requirements on alignment */
SC_ASSERT (sizeof (char **) == sizeof (void *));
SC_ASSERT (sizeof (char **) >= sizeof (size_t));
SC_ASSERT (alignment > 0 && alignment % sizeof (void *) == 0);
#if defined SC_HAVE_ANY_MEMALIGN && \
(defined SC_HAVE_POSIX_MEMALIGN || defined SC_HAVE_ALIGNED_ALLOC)
free (ptr);
#else
{
#if 0
int *datastart = ptr;
int shift = datastart[-1];
datastart -= shift;
free ((void *) datastart);
#endif
/* this mirrors the function sc_malloc_aligned above */
char *alloc_ptr;
#ifdef SC_ENABLE_DEBUG
const ptrdiff_t extrasize = (const ptrdiff_t) (2 * sizeof (char **));
const ptrdiff_t signalign = (const ptrdiff_t) alignment;
ptrdiff_t shift, modu, ssize, i;
#endif
/* we excluded these cases earlier */
SC_ASSERT (ptr != NULL);
SC_ASSERT ((ptrdiff_t) ptr % signalign == 0);
alloc_ptr = ((char **) ptr)[-1];
SC_ASSERT (alloc_ptr != NULL);
#ifdef SC_ENABLE_DEBUG
/* compute shift to the right where we put the actual data */
ssize = (ptrdiff_t) ((char **) ptr)[-2];
modu = ((ptrdiff_t) alloc_ptr + extrasize) % signalign;
shift = (signalign - modu) % signalign;
SC_ASSERT (0 <= shift && shift < signalign);
SC_ASSERT ((char *) ptr == alloc_ptr + (extrasize + shift));
for (i = 0; i < shift; ++i) {
SC_ASSERT (alloc_ptr[i] == -2);
}
for (i = 0; i < signalign - shift; ++i) {
SC_ASSERT (((char *) ptr)[ssize + i] == -2);
}
#endif
/* free the original pointer */
free (alloc_ptr);
}
#endif
}
sc_dmatrix_t *
sc_bspline_knots_new_length_periodic (int n, sc_dmatrix_t * points)
{
const int d = points->n;
const int p = points->m - 1;
const int m = n + p + 1;
const int l = m - 2 * n;
int i, k;
double distsqr, distsum, distalln;
double *knotse;
sc_dmatrix_t *knots;
SC_ASSERT (n >= 1);
SC_ASSERT (n >= 0 && m >= 1 && d >= 1 && l >= 1);
knots = sc_dmatrix_new_zero (m + 1, 1);
knotse = knots->e[0];
/* compute cumulative distance from P_0 and hide inside knots */
distsum = 0.;
for (i = 0; i < p; ++i) {
SC_ASSERT (n + i + 2 >= 0 && n + i + 2 <= m);
distsqr = 0.;
for (k = 0; k < d; ++k) {
distsqr += SC_SQR (points->e[i + 1][k] - points->e[i][k]);
}
knotse[n + i + 2] = sqrt (distsqr);
if (i < l) {
distsum += knotse[n + i + 2];
}
}
distalln = distsum * n;
/* assign average cumulative distance to knot value */
knotse[n] = 0.;
for (i = 1; i < l; ++i) {
distsum = 0.;
for (k = 0; k < n; ++k) {
SC_ASSERT (n + i + k + 1 <= m);
distsum += knotse[n + i + k + 1];
}
knotse[n + i] = knotse[n + i - 1] + distsum / distalln;
}
knotse[n + l] = 1.;
/* fill in the beginning and end values */
for (i = 0; i < n; ++i) {
knotse[i] = knotse[i + l] - 1.;
knotse[m - i] = knotse[2 * n - i] + 1.;
}
return knots;
}
void
sc_finalize (void)
{
int i;
int retval;
/* sc_packages is static and thus initialized to all zeros */
for (i = SC_MAX_PACKAGES - 1; i >= 0; --i)
if (sc_packages[i].is_registered)
sc_package_unregister (i);
SC_ASSERT (sc_num_packages == 0);
sc_memory_check (-1);
sc_set_signal_handler (0);
sc_mpicomm = MPI_COMM_NULL;
sc_print_backtrace = 0;
sc_identifier = -1;
/* close trace file */
if (sc_trace_file != NULL) {
retval = fclose (sc_trace_file);
SC_CHECK_ABORT (!retval, "Trace file close");
sc_trace_file = NULL;
}
}
void _SC_process_out_reject(int fd, int mask, void *a)
{int i, n, nr;
PROCESS *pp;
taskdesc *job;
parstate *state;
asyncstate *as;
GET_SERVER_STATE(as);
state = (parstate *) a;
SC_START_ACTIVITY(state, EXEC_OUT_REJECT);
nr = SC_running_children();
SC_ASSERT(nr >= 0);
n = SC_array_get_n(state->tasks);
for (i = 0; i < n; i++)
{job = *(taskdesc **) SC_array_get(state->tasks, i);
if (job != NULL)
{pp = job->pp;
if (SC_process_alive(pp))
{
/*
fprintf(stderr, "%-16s: %4d %8d (%d/%d)\n", "out_reject", SC_current_thread(), pp->id, pp->status, pp->reason);
*/
if ((pp->io[0] == fd) && (SC_status(pp) == SC_RUNNING))
_SC_rejected_process(as, state, job, mask);};};};
SC_END_ACTIVITY(state);
return;}
sc_dmatrix_t *
sc_bspline_knots_new (int n, sc_dmatrix_t * points)
{
#ifdef SC_DEBUG
const int d = points->n;
#endif
const int p = points->m - 1;
const int m = n + p + 1;
const int l = m - 2 * n;
int i;
sc_dmatrix_t *knots;
double *knotse;
SC_ASSERT (n >= 0 && m >= 1 && d >= 1 && l >= 1);
knots = sc_dmatrix_new (m + 1, 1);
knotse = knots->e[0];
for (i = 0; i < n; ++i) {
knotse[i] = 0.;
knotse[m - i] = 1.;
}
for (i = 0; i <= l; ++i) {
knotse[n + i] = i / (double) l;
}
return knots;
}
void *va_get_element (var_array *var_arr, int index)
{
ASSERT (var_arr);
SC_ASSERT (index >= 0 && index < var_arr->num_elements);
return (var_arr->elements[index]);
}
void
sc_allgather_alltoall (sc_MPI_Comm mpicomm, char *data, int datasize,
int groupsize, int myoffset, int myrank)
{
int j, peer;
int mpiret;
sc_MPI_Request *request;
SC_ASSERT (myoffset >= 0 && myoffset < groupsize);
request = SC_ALLOC (sc_MPI_Request, 2 * groupsize);
for (j = 0; j < groupsize; ++j) {
if (j == myoffset) {
request[j] = request[groupsize + j] = sc_MPI_REQUEST_NULL;
continue;
}
peer = myrank - (myoffset - j);
mpiret = sc_MPI_Irecv (data + j * datasize, datasize, sc_MPI_BYTE,
peer, SC_TAG_AG_ALLTOALL, mpicomm, request + j);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Isend (data + myoffset * datasize, datasize, sc_MPI_BYTE,
peer, SC_TAG_AG_ALLTOALL,
mpicomm, request + groupsize + j);
SC_CHECK_MPI (mpiret);
}
mpiret = sc_MPI_Waitall (2 * groupsize, request, sc_MPI_STATUSES_IGNORE);
SC_CHECK_MPI (mpiret);
SC_FREE (request);
}
static int ps_test(char *name, int color, int debug_mode, int nt, gtest tst)
{int ok;
long sc;
PG_device *dev;
ok = TRUE;
sc = test_check(name, -1L, debug_mode);
register_devices();
if (color)
dev = PG_make_device("PS", "COLOR", name);
else
dev = PG_make_device("PS", "MONOCHROME PORTRAIT", name);
PG_open_device(dev, 0.0, 0.0, 0.0, 0.0);
ok &= (*tst)(dev);
PG_close_device(dev);
PG_rl_all();
sc = test_check(name, 1L, debug_mode);
SC_ASSERT(sc == TRUE);
return(ok);}
void
sc_memory_check (int package)
{
sc_package_t *p;
if (package == -1) {
SC_CHECK_ABORT (default_rc_active == 0, "Leftover references (default)");
if (default_abort_mismatch) {
SC_CHECK_ABORT (default_malloc_count == default_free_count,
"Memory balance (default)");
}
else if (default_malloc_count != default_free_count) {
SC_GLOBAL_LERROR ("Memory balance (default)\n");
}
}
else {
SC_ASSERT (sc_package_is_registered (package));
p = sc_packages + package;
SC_CHECK_ABORTF (p->rc_active == 0, "Leftover references (%s)", p->name);
if (p->abort_mismatch) {
SC_CHECK_ABORTF (p->malloc_count == p->free_count,
"Memory balance (%s)", p->name);
}
else if (p->malloc_count != p->free_count) {
SC_GLOBAL_LERRORF ("Memory balance (%s)\n", p->name);
}
}
}
sc_dmatrix_t *
sc_bspline_workspace_new (int n, int d)
{
SC_ASSERT (n >= 0 && d >= 1);
return sc_dmatrix_new ((n + 1) * (n + 1), d);
}
void
sc_bspline_evaluate (sc_bspline_t * bs, double t, double *result)
{
int i, k, n;
int iguess;
int toffset;
double *wfrom, *wto;
const double *knotse = bs->knots->e[0];
iguess = sc_bspline_find_interval (bs, t);
toffset = 0;
wfrom = wto = bs->points->e[iguess - bs->n];
for (n = bs->n; n > 0; --n) {
wto = bs->works->e[toffset];
for (i = 0; i < n; ++i) {
const double tleft = knotse[iguess + i - n + 1];
const double tright = knotse[iguess + i + 1];
const double tfactor = 1. / (tright - tleft);
for (k = 0; k < bs->d; ++k) {
wto[bs->d * i + k] =
((t - tleft) * wfrom[bs->d * (i + 1) + k] +
(tright - t) * wfrom[bs->d * i + k]) * tfactor;
}
}
wfrom = wto;
toffset += n;
}
SC_ASSERT (toffset == bs->n * (bs->n + 1) / 2);
memcpy (result, wfrom, sizeof (double) * bs->d);
}
void va_set_element (var_array *var_arr, int index, void *element)
{
ASSERT (var_arr);
SC_ASSERT (index >= 0 && index < var_arr->num_elements);
var_arr->elements[index] = element;
}
static int time_timer(int nt, int ni)
{int it, rv;
double ap, tt;
volatile double ta;
io_printf(stdout, "\t\t\ttime timer ........ ");
rv = TRUE;
tt = SC_wall_clock_time();
ni *= 200;
for (it = 0; it < ni; it++)
ta = SC_wall_clock_time();
SC_ASSERT(ta > tt);
tt = SC_wall_clock_time() - tt;
ap = tt/((double) ni);
io_printf(stdout, "ok\n\n");
io_printf(stdout, "\t\t Iter Ttot Tper\n");
io_printf(stdout, "\t\t%8d %10.2e %10.2e\n\n", it, tt, ap);
return(rv);}
int
sc_vtk_write_binary (FILE * vtkfile, char *numeric_data, size_t byte_length)
{
size_t chunks, chunksize, remaining, writenow;
size_t code_length, base_length;
uint32_t int_header;
char *base_data;
base64_encodestate encode_state;
/* VTK format used 32bit header info */
SC_ASSERT (byte_length <= (size_t) UINT32_MAX);
chunksize = (size_t) 1 << 15; /* 32768 */
int_header = (uint32_t) byte_length;
code_length = 2 * chunksize;
base_data = SC_ALLOC (char, code_length);
base64_init_encodestate (&encode_state);
base_length =
base64_encode_block ((char *) &int_header, sizeof (int_header), base_data,
&encode_state);
base_data[base_length] = '\0';
(void) fwrite (base_data, 1, base_length, vtkfile);
chunks = 0;
remaining = byte_length;
while (remaining > 0) {
writenow = SC_MIN (remaining, chunksize);
base_length = base64_encode_block (numeric_data + chunks * chunksize,
writenow, base_data, &encode_state);
base_data[base_length] = '\0';
SC_ASSERT (base_length < code_length);
(void) fwrite (base_data, 1, base_length, vtkfile);
remaining -= writenow;
++chunks;
}
base_length = base64_encode_blockend (base_data, &encode_state);
(void) fwrite (base_data, 1, base_length, vtkfile);
SC_FREE (base_data);
if (ferror (vtkfile)) {
return -1;
}
return 0;
}
Boat *
boat_get_data (sc_object_t * o)
{
SC_ASSERT (sc_object_is_type (o, boat_type));
return (Boat *) sc_object_data_lookup (o, (sc_object_method_t)
boat_get_data);
}
Boat *
boat_register_data (sc_object_t * o)
{
SC_ASSERT (sc_object_is_type (o, boat_type));
return (Boat *) sc_object_data_register (o, (sc_object_method_t)
boat_get_data, sizeof (Boat));
}
double
sc_function1_invert (sc_function1_t func, void *data,
double x_low, double x_high, double y, double rtol)
{
const int k_max = 100;
int k;
double x, sign;
double y_target, y_low, y_high, y_tol;
SC_ASSERT (x_low < x_high && rtol > 0.);
y_target = y;
if (func == NULL)
return y_target;
y_low = func (x_low, data);
y_high = func (x_high, data);
y_tol = rtol * fabs (y_high - y_low);
sign = (y_low <= y_high) ? 1. : -1.;
SC_ASSERT ((sign > 0. && y_low <= y_target && y_target <= y_high) ||
(sign < 0. && y_high <= y_target && y_target <= y_low));
for (k = 0; k < k_max; ++k) {
x = x_low + (x_high - x_low) * (y_target - y_low) / (y_high - y_low);
if (x <= x_low) {
return x_low;
}
if (x >= x_high) {
return x_high;
}
y = func (x, data);
if (sign * (y - y_target) < -y_tol) {
x_low = x;
y_low = y;
}
else if (sign * (y - y_target) > y_tol) {
x_high = x;
y_high = y;
}
else
return x;
}
SC_ABORTF ("sc_function1_invert did not converge after %d iterations", k);
}
double
sc_product3 (double x, double y, double z, void *data)
{
sc_function3_meta_t *meta = (sc_function3_meta_t *) data;
SC_ASSERT (meta != NULL);
return meta->f1 (x, y, z, meta->data) *
((meta->f2 != NULL) ? meta->f2 (x, y, z, meta->data) : meta->parameter2);
}
static int *
sc_free_count (int package)
{
if (package == -1)
return &default_free_count;
SC_ASSERT (sc_package_is_registered (package));
return &sc_packages[package].free_count;
}
bool Wait(uint32_t timeout_ms = 5000)
{
if (m_waitStartDelegate)
m_waitStartDelegate();
SC_ASSERT(timeout_ms < 60000, ("Too big timeout (it should be less then a minute)"));
return m_waiterImpl.Wait(timeout_ms);
}
double
sc_tensor3 (double x, double y, double z, void *data)
{
sc_function3_meta_t *meta = (sc_function3_meta_t *) data;
SC_ASSERT (meta != NULL);
return meta->f1 (x, y, z, meta->data) *
meta->f2 (x, y, z, meta->data) * meta->f3 (x, y, z, meta->data);
}
void
sc_bspline_make_points_periodic (int n, sc_dmatrix_t * points)
{
const int d = points->n;
const int l = points->m;
const int p = n + l - 1;
const int shift = (n / 2);
int i, j;
SC_ASSERT (d > 0 && n >= 0 && l > 0);
if (!n) {
/* already periodic */
return;
}
sc_dmatrix_resize (points, p + 1, d);
/* shift to make room for the starting points */
for (i = l - 1; i >= 0; i--) {
for (j = 0; j < d; j++) {
SC_ASSERT (i + shift <= p);
points->e[i + shift][j] = points->e[i][j];
}
}
/* copy the starting points */
for (i = 0; i < shift; i++) {
for (j = 0; j < d; j++) {
SC_ASSERT (i + l <= p);
points->e[i][j] = points->e[i + l][j];
}
}
/* copy the ending points */
for (i = shift + l; i <= p; i++) {
for (j = 0; j < d; j++) {
SC_ASSERT (i - l >= 0);
points->e[i][j] = points->e[i - l][j];
}
}
SC_ASSERT (sc_dmatrix_is_valid (points));
}
void *
sc_calloc (int package, size_t nmemb, size_t size)
{
void *ret;
int *malloc_count = sc_malloc_count (package);
#ifdef SC_ALLOC_ALIGN
size_t aligned;
if (size == 0) {
return NULL;
}
nmemb += (sc_page_bytes + size - 1) / size;
#endif
ret = calloc (nmemb, size);
if (nmemb * size > 0) {
SC_CHECK_ABORT (ret != NULL, "Allocation");
++*malloc_count;
}
else {
*malloc_count += ((ret == NULL) ? 0 : 1);
}
#ifdef SC_ALLOC_PAGE
aligned = (((size_t) ret + sizeof (size_t) + sc_page_bytes - 1) /
sc_page_bytes) * sc_page_bytes;
#endif
#ifdef SC_ALLOC_LINE
aligned = (((size_t) ret + sizeof (size_t) +
sc_page_bytes - sc_line_no * sc_line_bytes - 1) /
sc_page_bytes) * sc_page_bytes + sc_line_no * sc_line_bytes;
sc_line_no = (sc_line_no + 1) % sc_line_count;
#endif
#ifdef SC_ALLOC_ALIGN
SC_ASSERT (aligned >= (size_t) ret + sizeof (size_t));
SC_ASSERT (aligned <= (size_t) ret + sc_page_bytes);
((size_t *) aligned)[-1] = (size_t) ret;
ret = (void *) aligned;
#endif
return ret;
}
