void promote_scalar_boolean_array(modelica_boolean s,int n,
boolean_array_t* dest)
{
int i;
/* Assert that dest is of correct dimension */
/* Alloc size */
dest->dim_size = size_alloc(n);
/* Alloc data */
dest->data = boolean_alloc(1);
dest->ndims = n;
boolean_set(dest, 0, s);
for(i = 0; i < n; ++i) {
dest->dim_size[i] = 1;
}
}
void base_array_create(base_array_t *dest, void *data, int ndims, va_list ap)
{
int i;
dest->data = data;
dest->ndims = ndims;
dest->dim_size = size_alloc(0,ndims);
for (i = 0; i < ndims; ++i) {
dest->dim_size[i] = va_arg(ap, int);
}
/* uncomment for debugging!
fprintf(stderr, "created array ndims[%d] (", ndims);
for (i = 0; i < ndims; ++i) {
fprintf(stderr, "size(%d)=[%d], ", i, (int)dest->dim_size[i]);
}
fprintf(stderr, ")\n"); fflush(stderr);
*/
}
void index_alloc_string_array(const string_array_t * source,
const index_spec_t* source_spec,
string_array_t* dest)
{
int i;
int j;
int ndimsdiff;
assert(base_array_ok(source));
assert(index_spec_ok(source_spec));
assert(index_spec_fit_base_array(source_spec, source));
ndimsdiff = 0;
for(i = 0; i < source_spec->ndims; ++i) {
if((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A')) {
ndimsdiff--;
}
}
dest->ndims = source->ndims + ndimsdiff;
dest->dim_size = size_alloc(dest->ndims);
for(i = 0,j = 0; i < dest->ndims; ++i) {
while(source_spec->index_type[i+j] == 'S') { /* Skip scalars */
j++;
}
if(source_spec->index_type[i+j] == 'W') { /*take whole dimension from source*/
dest->dim_size[i]=source->dim_size[i+j];
} else if(source_spec->index_type[i+j] == 'A') { /* Take dimension size from splice*/
dest->dim_size[i]=source_spec->dim_size[i+j];
}
}
alloc_string_array_data(dest);
index_string_array(source, source_spec, dest);
}
size_t alloc_base_array(base_array_t *dest, int ndims, va_list ap)
{
int i;
size_t nr_of_elements = 1;
dest->ndims = ndims;
dest->dim_size = size_alloc(0,ndims);
for (i = 0; i < ndims; ++i) {
dest->dim_size[i] = va_arg(ap, _index_t);
nr_of_elements *= dest->dim_size[i];
}
/* uncomment for debugging!
fprintf(stderr, "alloc array ndims[%d] (", ndims);
for (i = 0; i < ndims; ++i) {
fprintf(stderr, "size(%d)=[%d], ", i, (int)dest->dim_size[i]);
}
fprintf(stderr, ")\n"); fflush(stderr);
*/
return nr_of_elements;
}
//���������������������������������������������������������������������������
// SimTimeTable - add_event
//
// This routine has been special cased for efficiency. The last case is
// actually sufficient, but some special situations that are easy to detect
// allow us to take some shortcuts. In particular, the tail append will
// probably be a BIG time-saver in common usage.
//���������������������������������������������������������������������������
void SimTimeTable::add_event (clock_t t, callback_t f, void *p)
{
assert ((head == 0 && tail == 0)
|| (head != 0 && tail != 0));
//��� Make sure there's room in the free_list
if (!free_list)
size_alloc (arena_size * 2);
//��� Allocate a new event
event *new_evt = free_list;
free_list = free_list->next;
new_evt->event::event (t, f, p);
//��� Decide where to put the new event (special cased for efficiency)
if (head == 0)
{
//��� This is the first and only node
head = tail = new_evt;
}
else if (tail->time <= t)
{
//��� Link the new node in at the end of the list
tail->next = new_evt;
tail = new_evt;
}
else if (tail == head)
{
//��� Link the new node in at the beginning of the single-item list
new_evt->next = head;
head = new_evt;
}
else
{
//��� Link the new node in at the appropriate location
event *curr_evt = head;
event *prev_evt = 0;
//��� Linear search is slow, but hopefully the common cases will have been caught above
while (curr_evt != 0 && curr_evt->time <= t)
{
prev_evt = curr_evt;
curr_evt = curr_evt->next;
}
new_evt->next = curr_evt;
if (!prev_evt)
head = new_evt; // new event inserted at top
else
{
prev_evt->next = new_evt;
if (curr_evt == 0)
tail = new_evt;
}
}
}
/* function: cat_alloc_real_array
*
* Concatenates n real arrays along the k:th dimension.
* allocates space in dest array
* k is one based
*/
void cat_alloc_real_array(int k, real_array_t* dest, int n,
real_array_t* first,...)
{
va_list ap;
int i, j, r, c;
int n_sub = 1, n_super = 1;
int new_k_dim_size = 0;
real_array_t **elts = (real_array_t**)malloc(sizeof(real_array_t *) * n);
assert(elts);
/* collect all array ptrs to simplify traversal.*/
va_start(ap, first);
elts[0] = first;
for (i = 1; i < n; i++) {
elts[i] = va_arg(ap,real_array_t*);
}
va_end(ap);
/* check dim sizes of all inputs */
assert(elts[0]->ndims >= k);
new_k_dim_size = elts[0]->dim_size[k-1];
for (i = 1; i < n; i++) {
assert(elts[0]->ndims == elts[i]->ndims);
for (j = 0; j < (k - 1); j++) {
assert(elts[0]->dim_size[j] == elts[i]->dim_size[j]);
}
new_k_dim_size += elts[i]->dim_size[k-1];
for (j = k; j < elts[0]->ndims; j++) {
assert(elts[0]->dim_size[j] == elts[i]->dim_size[j]);
}
}
/* calculate size of sub and super structure in 1-dim data representation */
for (i = 0; i < (k - 1); i++) {
n_super *= elts[0]->dim_size[i];
}
for (i = k; i < elts[0]->ndims; i++) {
n_sub *= elts[0]->dim_size[i];
}
/* allocate dest structure */
dest->data = real_alloc(0, n_super * new_k_dim_size * n_sub);
dest->ndims = elts[0]->ndims;
dest->dim_size = size_alloc(0,dest->ndims);
for (j = 0; j < dest->ndims; j++) {
dest->dim_size[j] = elts[0]->dim_size[j];
}
dest->dim_size[k-1] = new_k_dim_size;
/* concatenation along k-th dimension */
j = 0;
for (i = 0; i < n_super; i++) {
for (c = 0; c < n; c++) {
int n_sub_k = n_sub * elts[c]->dim_size[k-1];
for (r = 0; r < n_sub_k; r++) {
real_set(dest, j,
real_get(elts[c], r + (i * n_sub_k)));
j++;
}
}
}
free(elts);
}
void index_alloc_real_array(const real_array_t * source,
const index_spec_t* source_spec,
real_array_t* dest)
{
int i;
int j;
/*int ndimsdiff;*/
assert(base_array_ok(source));
assert(index_spec_ok(source_spec));
assert(index_spec_fit_base_array(source_spec, source));
/*
ndimsdiff = 0;
for (i = 0; i < source_spec->ndims; ++i) {
if ((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A'))
ndimsdiff--;
}
/ * !!! this is a major bug here, it should be
* dest->ndims = -ndimsdiff;
* for example in
* (to be allocated)dest := source[{2,3}];
* it leads to 0 ndims ... 1 - 1
* and, in the next lines,
* memory was written after its allocated area (not used in fact)
* /
dest->ndims = source->ndims + ndimsdiff;
assert(dest->ndims > 0); / * dest->ndims <= 0 was happenning ... * /
dest->dim_size = size_alloc(0,dest->ndims);
for (i = 0,j = 0; i < dest->ndims; ++i) {
/ * !!! a little bug is here !!!
* When source_spec is in line with dest, everything is ok,
* for every dest dimension there has to be a 'W' or 'A',
* but when the input is incorrect, what is not tested/asserted yet,
* there can be the last index_type[i+j] == 'S'
* --> index out of bounds
* --> corrupted memory in the next lines --> nondeterministic behavior
* /
while (source_spec->index_type[i+j] == 'S') ++j; / * Skip scalars * /
if (source_spec->index_type[i+j] == 'W') { / *take whole dimension from source* /
dest->dim_size[i]=source->dim_size[i+j];
} else if (source_spec->index_type[i+j] == 'A') { / * Take dimension size from splice* /
dest->dim_size[i]=source_spec->dim_size[i+j];
}
}
*/
for (i = 0, j = 0; i < source_spec->ndims; ++i) {
if (source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
++j;
}
}
dest->ndims = j;
dest->dim_size = size_alloc(0,dest->ndims);
for (i = 0, j = 0; i < source_spec->ndims; ++i) {
if (source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
if(source_spec->index[i] != NULL) { /* is 'A' */
dest->dim_size[j] = source_spec->dim_size[i];
} else { /* is 'W' */
dest->dim_size[j] = source->dim_size[i];
}
++j;
}
}
alloc_real_array_data(dest);
index_real_array(source, source_spec, dest);
}
void index_real_array(const real_array_t * source,
const index_spec_t* source_spec,
real_array_t* dest)
{
_index_t* idx_vec1;
_index_t* idx_size;
int j;
int i;
state mem_state;
assert(base_array_ok(source));
assert(base_array_ok(dest));
assert(index_spec_ok(source_spec));
assert(index_spec_fit_base_array(source_spec,source));
/*for (i = 0, j = 0; i < source->ndims; ++i)
{
printf("source_spec->index_type[%d] = %c\n", i, source_spec->index_type[i]);
if ((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A'))
++j;
}
assert(j == dest->ndims);*/
for (i = 0,j = 0; i < source_spec->ndims; ++i) {
if (source_spec->dim_size[i] != 0) {
++j;
}
}
assert(j == dest->ndims);
mem_state = get_memory_state();
idx_vec1 = size_alloc(0,source->ndims); /*indices in the source array*/
/* idx_vec2 = size_alloc(0,dest->ndims); / * indices in the destination array* / */
idx_size = size_alloc(0,source_spec->ndims);
for (i = 0; i < source->ndims; ++i) {
idx_vec1[i] = 0;
}
for (i = 0; i < source_spec->ndims; ++i) {
if (source_spec->index[i] != NULL) { /* is 'S' or 'A' */
idx_size[i] = imax(source_spec->dim_size[i],1); /* the imax() is not needed, because there is (idx[d] >= size[d]) in the next_index(), but ... */
} else { /* is 'W' */
idx_size[i] = source->dim_size[i];
}
}
j = 0;
do {
/*
for (i = 0, j = 0; i < source->ndims; ++i) {
if ((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A')) {
idx_vec2[j] = idx_vec1[i];
j++;
}
}
*/
real_set(dest, j, /* calc_base_index(dest->ndims, idx_vec2, dest), */
real_get(source,
calc_base_index_spec(source->ndims, idx_vec1,
source, source_spec)));
j++;
} while (0 == next_index(source->ndims, idx_vec1, idx_size));
assert(j == base_array_nr_of_elements(dest));
restore_memory_state(mem_state);
}
void indexed_assign_real_array(const real_array_t * source,
real_array_t* dest,
const index_spec_t* dest_spec)
{
_index_t* idx_vec1;
_index_t* idx_size;
int i,j;
state mem_state;
assert(base_array_ok(source));
assert(base_array_ok(dest));
assert(index_spec_ok(dest_spec));
assert(index_spec_fit_base_array(dest_spec, dest));
for (i = 0,j = 0; i < dest_spec->ndims; ++i) {
if (dest_spec->dim_size[i] != 0) {
++j;
}
}
assert(j == source->ndims);
mem_state = get_memory_state();
idx_vec1 = size_alloc(0,dest->ndims);
/* idx_vec2 = size_alloc(0,source->ndims); */
idx_size = size_alloc(0,dest_spec->ndims);
for (i = 0; i < dest_spec->ndims; ++i) {
idx_vec1[i] = 0;
if (dest_spec->index[i] != NULL) { /* is 'S' or 'A' */
idx_size[i] = imax(dest_spec->dim_size[i],1);
} else { /* is 'W' */
idx_size[i] = dest->dim_size[i];
}
}
j = 0;
do {
/*for (i = 0, j = 0; i < dest_spec->ndims; ++i) {
if (dest_spec->dim_size[i] != 0) {
idx_vec2[j] = idx_vec1[i];
++j;
}
}*/
/*for (i = 0, j = 0; i < dest_spec->ndims; ++i) {
if ((dest_spec->index_type[i] == 'W')
||
(dest_spec->index_type[i] == 'A')) {
idx_vec2[j] = idx_vec1[i];
++j;
}
}*/
real_set(dest,
calc_base_index_spec(dest->ndims, idx_vec1, dest, dest_spec),
real_get(source, j));
j++;
/* calc_base_index(source->ndims, idx_vec1, source)));*/
/* calc_base_index(source->ndims, idx_vec2, source)));*/
} while (0 == next_index(dest_spec->ndims, idx_vec1, idx_size));
assert(j == base_array_nr_of_elements(source));
restore_memory_state(mem_state);
}
void atomic_cycle_distribution(
vtx_t const nvtxs,
adj_t const * const xadj,
vtx_t const * const adjncy,
adj_t * radj,
size_t ** const r_cycles,
vtx_t * const r_maxcycle)
{
int free_radj;
vtx_t i, k, v, m, sq, nq, si, ni, curlen, maxlen;
adj_t j, l;
vtx_t * q, * qi, * len;
int * vvisited, * evisited, * ivisited;
size_t * cycles;
adj_t const nedges = xadj[nvtxs];
q = vtx_alloc(nvtxs);
qi = vtx_alloc(nvtxs);
vvisited = int_calloc(nvtxs);
evisited = int_calloc(nedges);
ivisited = int_calloc(nvtxs);
cycles = size_alloc(dl_min(nvtxs,nedges));
len = vtx_alloc(nvtxs);
if (radj) {
free_radj = 0;
} else {
radj = adj_alloc(nedges);
build_adjncy_index(nvtxs,xadj,adjncy,radj);
free_radj = 1;
}
maxlen = 0;
cycles[0] = 0;
/* seed the queue */
sq = nq = 0;
v = vtx_rand(0,nvtxs);
q[nq++] = v;
vvisited[v] = 1;
/* algorithm from Gashler and Martinez 2012 */
while (sq < nq) {
v = q[sq++];
for (j=xadj[v];j<xadj[v+1];++j) {
k = adjncy[j];
if (vvisited[k]) {
len[k] = 1;
si = ni = 0;
qi[ni++] = k;
ivisited[k] = 1;
while (si < ni) {
i = qi[si++];
for (l=xadj[i];l<xadj[i+1];++l) {
m = adjncy[l];
if (!ivisited[m] && evisited[l]) {
len[m] = len[i]+1;
qi[ni++] = m;
ivisited[m] = 1;
if (m == v) {
curlen = len[m];
/* zero out new cycle lengths */
while (curlen > maxlen) {
cycles[++maxlen] = 0;
}
++cycles[curlen];
/* I might need to break here */
si = ni;
break;
}
}
}
}
/* clear ivisited */
if (ni < nvtxs/64) {
for (i=0;i<ni;++i) {
ivisited[qi[i]] = 0;
}
} else {
int_set(ivisited,0,nvtxs);
}
} else {
q[nq++] = k;
vvisited[k] = 1;
}
evisited[j] = 1;
evisited[radj[j]] = 1;
}
}
/* hack to ignore length 2 cycles */
cycles[2] = 0;
if (r_maxcycle) {
*r_maxcycle = maxlen;
}
if (r_cycles) {
*r_cycles = cycles;
}
if (free_radj) {
dl_free(radj);
}
}
