/* ** Reset each relation until limit. ** Reset will remove all tuples from the ** relation but not destroy the relation. ** The descriptor for the relation will be removed ** from the cache. ** ** The original relation is returned to ** the range table. ** ** If limit is -1 then all relations are done. */ void reset_sq(qtree_t **sqlist, int *locrang, int limit) { register qtree_t *sq; register int i, lim; int old, reset; lim = limit == -1 ? MAX_RANGES : limit; reset = FALSE; initp(); for (i = 0; i < lim; i++) if ((sq = sqlist[i]) && sq->left->sym.type != TREE) { old = new_range(i, locrang[i]); setp(PV_STR, rnum_convert(old), 0); specclose(old); reset = TRUE; } if (reset) { /* ** Guarantee that OVQP will not reuse old ** page of relation being reset */ De.de_newr = TRUE; call_dbu(mdRESETREL, FALSE); } else resetp(); }
/* ** Check the range table to see if any ** relations changed since the last call ** to newquery. If so, they were caused ** by reformat. Restore back the orig relation ** Reopen it if reopen == TRUE. */ void endquery(int *locrang, int reopen) { register struct rang_tab *rp; register int *ip, i; int old; bool dstr_flag; rp = De.de_rangev; ip = locrang; dstr_flag = FALSE; initp(); for (i = 0; i < MAX_RANGES; i++) { if (rp->relnum != *ip) { #ifdef xDTR1 if (tTf(63, -1)) printf("reformat or reduct changed var %d (%d,%d)\n", i, *ip, rp->relnum); #endif old = new_range(i, *ip); dstr_flag |= dstr_mark(old); if (reopen) openr1(i); } ip++; rp++; } if (dstr_flag) call_dbu(mdDESTROY, FALSE); else resetp(); }
void Tokenizer::TokenizeByDelimiter(bool enclosed, const TokenRange& range) { // Each group occasionally has a different delimiter, which is why we can't // analyze the whole filename in one go. const char_t delimiter = GetDelimiter(range); // TODO: Better handle groups with multiple delimiters if (!ValidateDelimiter(delimiter, enclosed, range)) { AddToken(kUnknown, enclosed, range); return; } TokenRange new_range(range.offset, 0); for (size_t offset = range.offset; offset < range.offset + range.size; offset++) { const char_t character = filename_.at(offset); if (character == delimiter) { // Add new unknown token if (new_range.offset < offset) { new_range.size = offset - new_range.offset; AddToken(kUnknown, enclosed, new_range); } // Add delimiter AddToken(kDelimiter, enclosed, TokenRange(offset, 1)); new_range.offset = offset + 1; } else if (offset == range.offset + range.size - 1) { // Add last unknown token new_range.size = offset - new_range.offset + 1; AddToken(kUnknown, enclosed, new_range); } } }
// Builds and scales a Gauss rule and a Jacobi rule. // Then combines them to compute points and weights // of a 3D conical product rule for the Tet. void QConical::conical_product_tet(unsigned int p) { // Be sure the underlying rule object was built with the same dimension as the // rule we are about to construct. libmesh_assert_equal_to (this->get_dim(), 3); QGauss gauss1D(1,static_cast<Order>(_order+2*p)); QJacobi jacA1D(1,static_cast<Order>(_order+2*p),1,0); QJacobi jacB1D(1,static_cast<Order>(_order+2*p),2,0); // The Gauss rule needs to be scaled to [0,1] std::pair<Real, Real> old_range(-1.0L, 1.0L); std::pair<Real, Real> new_range( 0.0L, 1.0L); gauss1D.scale(old_range, new_range); // Now construct the points and weights for the conical product rule. // All rules should have the same number of points libmesh_assert_equal_to (gauss1D.n_points(), jacA1D.n_points()); libmesh_assert_equal_to (jacA1D.n_points(), jacB1D.n_points()); // Save the number of points as a convenient variable const unsigned int np = gauss1D.n_points(); // All rules should be between x=0 and x=1 libmesh_assert_greater_equal (gauss1D.qp(0)(0), 0.0); libmesh_assert_less_equal (gauss1D.qp(np-1)(0), 1.0); libmesh_assert_greater_equal (jacA1D.qp(0)(0), 0.0); libmesh_assert_less_equal (jacA1D.qp(np-1)(0), 1.0); libmesh_assert_greater_equal (jacB1D.qp(0)(0), 0.0); libmesh_assert_less_equal (jacB1D.qp(np-1)(0), 1.0); // Resize the points and weights vectors _points.resize(np * np * np); _weights.resize(np * np * np); // Compute the conical product unsigned int gp = 0; for (unsigned int i=0; i<np; i++) for (unsigned int j=0; j<np; j++) for (unsigned int k=0; k<np; k++) { _points[gp](0) = jacB1D.qp(k)(0); //t[k]; _points[gp](1) = jacA1D.qp(j)(0) * (1.-jacB1D.qp(k)(0)); //s[j]*(1.-t[k]); _points[gp](2) = gauss1D.qp(i)(0) * (1.-jacA1D.qp(j)(0)) * (1.-jacB1D.qp(k)(0)); //r[i]*(1.-s[j])*(1.-t[k]); _weights[gp] = gauss1D.w(i) * jacA1D.w(j) * jacB1D.w(k); //A[i]*B[j]*C[k]; gp++; } }
/* ** EXEC_SQ ** ** Execute the subqueries in sqlist. Associated with ** each sub-query is a relation number stored in sqrange. ** If the sub-query has a non-null target list, the range ** table is updated to reflect the new range of the relation. ** ** If any sub-query is false, all subsequent ones are ignored ** by ovqp and exec_sq returns the var number of the false subquery. ** ** As a side effect, "disj" is incremented for each disjoint sub-query ** ** Trace Flags: ** 35 */ int exec_sq(qtree_t **sqlist, int *sqrange, int *disj) { register qtree_t *sq; register int i, qualfound; #ifdef xDTR1 if (tTf(35, 0)) printf("EXEC_SQ--\n"); #endif *disj = 0; for (i = 0; i < MAX_RANGES; i++) { if ((sq = sqlist[i]) != 0) { #ifdef xDTR1 if (tTf(35, 1)) printf("sq[%d]=%p\n", i, sq); #endif qualfound = execsq1(sq, i, sqrange[i]); #ifdef xDTR1 if (tTf(35, 2)) printf("qualfound=%d\n", qualfound); #endif if (!qualfound) { return(i); } if (sq->left->sym.type != TREE) { /* ** Update the range table and open ** the relation's restricted replacement. */ new_range(i, sqrange[i]); openr1(i); } else { (*disj)++; } } } return (-1); }
void test_dim(int ndim) { int dim,elems; int i,j, proc; /* double a[DIM4][DIM3][DIM2][DIM1], b[EDIM4][EDIM3][EDIM2][EDIM1];*/ double *b; double *a, *a1, *a2, *c; int ridx; MPI_Datatype typeA, typeB; int rstrideB[MAXDIMS]; int rcount[MAXDIMS]; int pidx1 = -1, pidx2 = -1, pidx3 = -1; elems = 1; strideA[0]=sizeof(double); strideB[0]=sizeof(double); for(i=0;i<ndim;i++){ strideA[i] *= dimsA[i]; strideB[i] *= dimsB[i]; if(i<ndim-1){ strideA[i+1] = strideA[i]; strideB[i+1] = strideB[i]; } elems *= dimsA[i]; } /* create shared and local arrays */ create_safe_array((void**)&b, sizeof(double),ndim,dimsB); a1 = (double *)malloc(sizeof(double)*elems); assert(a1); a2 = (double *)malloc(sizeof(double)*elems); assert(a2); c = (double *)malloc(sizeof(double)*elems); assert(c); init(a1, ndim, elems, dimsA, me!=0, 0); init(a2, ndim, elems, dimsA, me!=0, 1); if(me==0){ printf("--------array[%d",dimsA[0]); for(dim=1;dim<ndim;dim++)printf(",%d",dimsA[dim]); printf("]--------\n"); } sleep(1); MP_BARRIER(); for(i=0;i<LOOP;i++){ int idx1, idx2, idx3, ridx; MPI_Request request; if (i%2) { a = a2; } else { a = a1; } get_range(ndim, dimsA, loA, hiA); new_range(ndim, dimsB, loA, hiA, loB, hiB); new_range(ndim, dimsA, loA, hiA, loC, hiC); proc=nproc-1-me; if(me==0){ print_range("local",ndim,loA, hiA,"-> "); print_range("remote",ndim,loB, hiB,"-> "); print_range("local",ndim,loC, hiC,"\n"); } idx1 = Index(ndim, loA, dimsA); idx2 = Index(ndim, loB, dimsB); idx3 = Index(ndim, loC, dimsA); MPI_Sendrecv(&idx2, 1, MPI_INT, proc, 666, &ridx, 1, MPI_INT, proc, 666, MPI_COMM_WORLD, MPI_STATUS_IGNORE); for(j=0;j<ndim;j++)count[j]=hiA[j]-loA[j]+1; count[0] *= sizeof(double); /* convert range to bytes at stride level zero */ Strided_to_dtype(strideA, count, ndim-1, MPI_BYTE, &typeA); MPI_Type_commit(&typeA); Strided_to_dtype(strideB, count, ndim-1, MPI_BYTE, &typeB); MPI_Type_commit(&typeB); MPI_Accumulate(a + idx1, 1, typeA, proc, (MPI_Aint)(idx2*sizeof(double)), 1, typeB, MPI_REPLACE, win); MP_FLUSH(proc); /* note that we do not need Fence here since * consectutive operations targeting the same process are ordered */ MPI_Get_accumulate(NULL, 0, MPI_BYTE, c + idx3, 1, typeA, proc, (MPI_Aint)(idx2*sizeof(double)), 1, typeB, MPI_NO_OP, win); MP_FLUSH(proc); compare_patches(0., ndim, a+idx1, loA, hiA, dimsA, c+idx3, loC, hiC, dimsA); pidx1 = idx1; pidx2 = idx2; pidx3 = idx3; MPI_Type_free(&typeA); MPI_Type_free(&typeB); } free(c); destroy_safe_array(); free(a); }