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