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; }