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