自学教程：C++ IBTK_TIMER_START函数代码示例

PetscErrorCodeVecMAXPY_SAMRAI(    Vec y,    PetscInt nv,    const PetscScalar* alpha,    Vec* x){    IBTK_TIMER_START(t_vec_maxpy);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(y != PETSC_NULL);    for (PetscInt i = 0; i < nv; ++i)    {        TBOX_ASSERT(x[i] != PETSC_NULL);    }#endif    static const bool interior_only = false;    for (PetscInt i = 0; i < nv; ++i)    {        if (MathUtilities<double>::equalEps(alpha[i],1.0))        {            PSVR_CAST2(y)->add(PSVR_CAST2(x[i]), PSVR_CAST2(y), interior_only);        }        else if (MathUtilities<double>::equalEps(alpha[i],-1.0))        {            PSVR_CAST2(y)->subtract(PSVR_CAST2(y), PSVR_CAST2(x[i]), interior_only);        }        else        {            PSVR_CAST2(y)->axpy(alpha[i], PSVR_CAST2(x[i]), PSVR_CAST2(y), interior_only);        }    }    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y)); IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_maxpy);    PetscFunctionReturn(0);}// VecMAXPY

PetscErrorCode VecNorm_local_SAMRAI(Vec x, NormType type, PetscScalar* val){    IBTK_TIMER_START(t_vec_norm_local);#if !defined(NDEBUG)    TBOX_ASSERT(x);#endif    static const bool local_only = true;    if (type == NORM_1)    {        *val = NormOps::L1Norm(PSVR_CAST2(x), local_only);    }    else if (type == NORM_2)    {        *val = NormOps::L2Norm(PSVR_CAST2(x), local_only);    }    else if (type == NORM_INFINITY)    {        *val = NormOps::maxNorm(PSVR_CAST2(x), local_only);    }    else if (type == NORM_1_AND_2)    {        val[0] = NormOps::L1Norm(PSVR_CAST2(x), local_only);        val[1] = NormOps::L2Norm(PSVR_CAST2(x), local_only);    }    else    {        TBOX_ERROR("PETScSAMRAIVectorReal::norm()/n"                   << "  vector norm type " << static_cast<int>(type) << " unsupported"                   << std::endl);    }    IBTK_TIMER_STOP(t_vec_norm_local);    PetscFunctionReturn(0);} // VecNorm_local

PetscErrorCodeVecWAXPY_SAMRAI(    Vec w,    PetscScalar alpha,    Vec x,    Vec y){    IBTK_TIMER_START(t_vec_waxpy);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(x != PETSC_NULL);    TBOX_ASSERT(y != PETSC_NULL);    TBOX_ASSERT(w != PETSC_NULL);#endif    static const bool interior_only = false;    if (MathUtilities<double>::equalEps(alpha,1.0))    {        PSVR_CAST2(w)->add(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);    }    else if (MathUtilities<double>::equalEps(alpha,-1.0))    {        PSVR_CAST2(w)->subtract(PSVR_CAST2(y), PSVR_CAST2(x), interior_only);    }    else    {        PSVR_CAST2(w)->axpy(alpha, PSVR_CAST2(x), PSVR_CAST2(y), interior_only);    }    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(w)); IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_waxpy);    PetscFunctionReturn(0);}// VecWAXPY

PetscErrorCode VecAYPX_SAMRAI(Vec y, const PetscScalar alpha, Vec x){    IBTK_TIMER_START(t_vec_aypx);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);#endif    static const bool interior_only = false;    if (MathUtilities<double>::equalEps(alpha, 1.0))    {        PSVR_CAST2(y)->add(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);    }    else if (MathUtilities<double>::equalEps(alpha, -1.0))    {        PSVR_CAST2(y)->subtract(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);    }    else    {        PSVR_CAST2(y)->axpy(alpha, PSVR_CAST2(y), PSVR_CAST2(x), interior_only);    }    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y));    IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_aypx);    PetscFunctionReturn(0);} // VecAYPX

boolPETScKrylovLinearSolver::solveSystem(SAMRAIVectorReal<NDIM, double>& x, SAMRAIVectorReal<NDIM, double>& b){    IBTK_TIMER_START(t_solve_system);#if !defined(NDEBUG)    TBOX_ASSERT(d_A);#endif    int ierr;    // Initialize the solver, when necessary.    const bool deallocate_after_solve = !d_is_initialized;    if (deallocate_after_solve) initializeSolverState(x, b);#if !defined(NDEBUG)    TBOX_ASSERT(d_petsc_ksp);#endif    resetKSPOptions();    // Allocate scratch data.    d_b->allocateVectorData();    // Solve the system using a PETSc KSP object.    d_b->copyVector(Pointer<SAMRAIVectorReal<NDIM, double> >(&b, false));    d_A->setHomogeneousBc(d_homogeneous_bc);    d_A->modifyRhsForBcs(*d_b);    d_A->setHomogeneousBc(true);    PETScSAMRAIVectorReal::replaceSAMRAIVector(d_petsc_x, Pointer<SAMRAIVectorReal<NDIM, double> >(&x, false));    PETScSAMRAIVectorReal::replaceSAMRAIVector(d_petsc_b, d_b);    ierr = KSPSolve(d_petsc_ksp, d_petsc_b, d_petsc_x);    IBTK_CHKERRQ(ierr);    d_A->setHomogeneousBc(d_homogeneous_bc);    d_A->imposeSolBcs(x);    // Get iterations count and residual norm.    ierr = KSPGetIterationNumber(d_petsc_ksp, &d_current_iterations);    IBTK_CHKERRQ(ierr);    ierr = KSPGetResidualNorm(d_petsc_ksp, &d_current_residual_norm);    IBTK_CHKERRQ(ierr);    d_A->setHomogeneousBc(d_homogeneous_bc);    // Determine the convergence reason.    KSPConvergedReason reason;    ierr = KSPGetConvergedReason(d_petsc_ksp, &reason);    IBTK_CHKERRQ(ierr);    const bool converged = (static_cast<int>(reason) > 0);    if (d_enable_logging) reportKSPConvergedReason(reason, plog);    // Dealocate scratch data.    d_b->deallocateVectorData();    // Deallocate the solver, when necessary.    if (deallocate_after_solve) deallocateSolverState();    IBTK_TIMER_STOP(t_solve_system);    return converged;} // solveSystem

PetscErrorCode VecGetLocalSize_SAMRAI(Vec v, PetscInt* size){    IBTK_TIMER_START(t_vec_get_local_size);#if !defined(NDEBUG)    TBOX_ASSERT(v);#endif    *size = v->map->n;    IBTK_TIMER_STOP(t_vec_get_local_size);    PetscFunctionReturn(0);} // VecGetLocalSize

PetscErrorCode VecMin_SAMRAI(Vec x, PetscInt* p, PetscScalar* val){    IBTK_TIMER_START(t_vec_min);#if !defined(NDEBUG)    TBOX_ASSERT(x);#endif    *p = -1;    *val = PSVR_CAST2(x)->min();    IBTK_TIMER_STOP(t_vec_min);    PetscFunctionReturn(0);} // VecMin

PetscErrorCode VecTDot_SAMRAI(Vec x, Vec y, PetscScalar* val){    IBTK_TIMER_START(t_vec_t_dot);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);#endif    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y));    IBTK_TIMER_STOP(t_vec_t_dot);    PetscFunctionReturn(0);} // VecTDot

PetscErrorCode VecMaxPointwiseDivide_SAMRAI(Vec x, Vec y, PetscScalar* max){    IBTK_TIMER_START(t_vec_max_pointwise_divide);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);#endif    *max = PSVR_CAST2(x)->maxPointwiseDivide(PSVR_CAST2(y));    IBTK_TIMER_STOP(t_vec_max_pointwise_divide);    PetscFunctionReturn(0);} // VecMaxPointwiseDivide

PetscErrorCode VecTDot_local_SAMRAI(Vec x, Vec y, PetscScalar* val){    IBTK_TIMER_START(t_vec_t_dot_local);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);#endif    static const bool local_only = true;    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y), local_only);    IBTK_TIMER_STOP(t_vec_t_dot_local);    PetscFunctionReturn(0);} // VecTDot_local

PetscErrorCode VecDotNorm2_SAMRAI(Vec s, Vec t, PetscScalar* dp, PetscScalar* nm){    IBTK_TIMER_START(t_vec_dot_norm2);#if !defined(NDEBUG)    TBOX_ASSERT(s);    TBOX_ASSERT(t);#endif    *dp = PSVR_CAST2(s)->dot(PSVR_CAST2(t));    *nm = PSVR_CAST2(t)->dot(PSVR_CAST2(t));    IBTK_TIMER_STOP(t_vec_dot_norm2);    PetscFunctionReturn(0);} // VecDotNorm2_SAMRAI

PetscErrorCode VecSet_SAMRAI(Vec x, PetscScalar alpha){    IBTK_TIMER_START(t_vec_set);#if !defined(NDEBUG)    TBOX_ASSERT(x);#endif    static const bool interior_only = false;    PSVR_CAST2(x)->setToScalar(alpha, interior_only);    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x));    IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_set);    PetscFunctionReturn(0);} // VecSet

PetscErrorCode VecCopy_SAMRAI(Vec x, Vec y){    IBTK_TIMER_START(t_vec_copy);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);#endif    static const bool interior_only = false;    PSVR_CAST2(y)->copyVector(PSVR_CAST2(x), interior_only);    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y));    IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_copy);    PetscFunctionReturn(0);} // VecCopy

boolCCDivGradHypreLevelSolver::solveSystem(    SAMRAIVectorReal<NDIM,double>& x,    SAMRAIVectorReal<NDIM,double>& b){    IBTK_TIMER_START(t_solve_system);    if (d_enable_logging) plog << d_object_name << "::solveSystem():" << std::endl;    // Initialize the solver, when necessary.    const bool deallocate_after_solve = !d_is_initialized;    if (deallocate_after_solve) initializeSolverState(x,b);    // Solve the system using the hypre solver.    static const int comp = 0;    const int x_idx = x.getComponentDescriptorIndex(comp);    const int b_idx = b.getComponentDescriptorIndex(comp);    bool converged = true;    IntVector<NDIM> chkbrd_mode_id;#if (NDIM > 2)    for (chkbrd_mode_id(2) = 0; chkbrd_mode_id(2) < 2; ++chkbrd_mode_id(2))    {#endif        for (chkbrd_mode_id(1) = 0; chkbrd_mode_id(1) < 2; ++chkbrd_mode_id(1))        {            for (chkbrd_mode_id(0) = 0; chkbrd_mode_id(0) < 2; ++chkbrd_mode_id(0))            {                bool converged_mode = solveSystem(x_idx, b_idx, chkbrd_mode_id);                if (d_enable_logging)                {                    plog << d_object_name << "::solveSystem(): solver " << (converged_mode ? "converged" : "diverged") << "/n"                         << "chkbrd_mode_id = " << chkbrd_mode_id << "/n"                         << "iterations = " << d_current_its << "/n"                         << "residual norm = " << d_current_residual_norm << std::endl;                }                converged = converged && converged_mode;            }        }#if (NDIM > 2)    }#endif    // Deallocate the solver, when necessary.    if (deallocate_after_solve) deallocateSolverState();    IBTK_TIMER_STOP(t_solve_system);    return converged;}// solveSystem

PetscErrorCodeVecGetLocalSize_SAMRAI(    Vec v,    PetscInt* n){    IBTK_TIMER_START(t_vec_get_local_size);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(v != PETSC_NULL);#else    NULL_USE(v);#endif    *n = 0;    IBTK_TIMER_STOP(t_vec_get_local_size);    PetscFunctionReturn(0);}// VecGetLocalSize

PetscErrorCodeVecScale_SAMRAI(    Vec x,    PetscScalar alpha){    IBTK_TIMER_START(t_vec_scale);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(x != PETSC_NULL);#endif    static const bool interior_only = false;    PSVR_CAST2(x)->scale(alpha,PSVR_CAST2(x), interior_only);    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x)); IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_scale);    PetscFunctionReturn(0);}// VecScale

PetscErrorCode VecPointwiseDivide_SAMRAI(Vec w, Vec x, Vec y){    IBTK_TIMER_START(t_vec_pointwise_divide);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);    TBOX_ASSERT(w);#endif    static const bool interior_only = false;    PSVR_CAST2(w)->divide(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(w));    IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_pointwise_divide);    PetscFunctionReturn(0);} // VecPointwiseDivide

PetscErrorCodeVecMaxPointwiseDivide_SAMRAI(    Vec x,    Vec y,    PetscScalar* max){    IBTK_TIMER_START(t_vec_max_pointwise_divide);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(x != PETSC_NULL);    TBOX_ASSERT(y != PETSC_NULL);#endif    *max = PSVR_CAST2(x)->maxPointwiseDivide(PSVR_CAST2(y));    IBTK_TIMER_STOP(t_vec_max_pointwise_divide);    PetscFunctionReturn(0);}// VecMaxPointwiseDivide

PetscErrorCodeVecMin_SAMRAI(    Vec x,    PetscInt* p,    PetscScalar* val){    IBTK_TIMER_START(t_vec_min);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(x != PETSC_NULL);#endif    *p = -1;    *val = PSVR_CAST2(x)->min();    IBTK_TIMER_STOP(t_vec_min);    PetscFunctionReturn(0);}// VecMin

PetscErrorCodeVecTDot_SAMRAI(    Vec x,    Vec y,    PetscScalar* val){    IBTK_TIMER_START(t_vec_t_dot);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(x != PETSC_NULL);    TBOX_ASSERT(y != PETSC_NULL);#endif    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y));    IBTK_TIMER_STOP(t_vec_t_dot);    PetscFunctionReturn(0);}// VecTDot

PetscErrorCodeVecDot_local_SAMRAI(    Vec x,    Vec y,    PetscScalar* val){    IBTK_TIMER_START(t_vec_dot_local);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(x != PETSC_NULL);    TBOX_ASSERT(y != PETSC_NULL);#endif    static const bool local_only = true;    *val = PSVR_CAST2(x)->dot(PSVR_CAST2(y), local_only);    IBTK_TIMER_STOP(t_vec_dot_local);    PetscFunctionReturn(0);}// VecDot_local

PetscErrorCode VecSetRandom_SAMRAI(Vec x, PetscRandom rctx){    IBTK_TIMER_START(t_vec_set_random);#if !defined(NDEBUG)    TBOX_ASSERT(x);#endif    PetscScalar lo, hi;    int ierr;    ierr = PetscRandomGetInterval(rctx, &lo, &hi);    IBTK_CHKERRQ(ierr);    PSVR_CAST2(x)->setRandomValues(hi - lo, lo);    ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x));    IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_set_random);    PetscFunctionReturn(0);} // VecSetRandom

PetscErrorCode VecSwap_SAMRAI(Vec x, Vec y){    IBTK_TIMER_START(t_vec_swap);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);#endif    PSVR_CAST2(x)->swapVectors(PSVR_CAST2(y));    int ierr;    ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(x));    IBTK_CHKERRQ(ierr);    ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(y));    IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_swap);    PetscFunctionReturn(0);} // VecSwap

void PETScNewtonKrylovSolver::deallocateSolverState(){    if (!d_is_initialized) return;    IBTK_TIMER_START(t_deallocate_solver_state);    int ierr;    // Deallocate the linear solver and operator states only if we are not    // re-initializing the Newton solver.    if (!d_reinitializing_solver)    {        if (d_krylov_solver) d_krylov_solver->deallocateSolverState();        if (d_J) d_J->deallocateOperatorState();        if (d_F) d_F->deallocateOperatorState();    }    // Delete the solution and rhs vectors.    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_x);    d_petsc_x = NULL;    d_x->freeVectorComponents();    d_x.setNull();    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_b);    d_petsc_b = NULL;    d_b->freeVectorComponents();    d_b.setNull();    PETScSAMRAIVectorReal::destroyPETScVector(d_petsc_r);    d_petsc_r = NULL;    d_r->freeVectorComponents();    d_r.setNull();    // Destroy the SNES solver.    if (d_managing_petsc_snes)    {        ierr = SNESDestroy(&d_petsc_snes);        IBTK_CHKERRQ(ierr);        d_petsc_snes = NULL;    }    // Indicate that the solver is NOT initialized.    d_is_initialized = false;    IBTK_TIMER_STOP(t_deallocate_solver_state);    return;} // deallocateSolverState

PetscErrorCodeVecDotNorm2_SAMRAI(    Vec s,    Vec t,    PetscScalar* dp,    PetscScalar* nm){    IBTK_TIMER_START(t_vec_dot_norm2);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(s != PETSC_NULL);    TBOX_ASSERT(t != PETSC_NULL);#endif    *dp = PSVR_CAST2(s)->dot(PSVR_CAST2(t));    *nm = PSVR_CAST2(t)->dot(PSVR_CAST2(t));    IBTK_TIMER_STOP(t_vec_dot_norm2);    PetscFunctionReturn(0);}// VecDotNorm2_SAMRAI

PetscErrorCodeVecAXPBYPCZ_SAMRAI(Vec z, PetscScalar alpha, PetscScalar beta, PetscScalar gamma, Vec x, Vec y){    IBTK_TIMER_START(t_vec_axpbypcz);#if !defined(NDEBUG)    TBOX_ASSERT(x);    TBOX_ASSERT(y);    TBOX_ASSERT(z);#endif    static const bool interior_only = false;    PSVR_CAST2(z)->linearSum(alpha, PSVR_CAST2(x), gamma, PSVR_CAST2(z), interior_only);    PSVR_CAST2(z)->axpy(beta, PSVR_CAST2(y), PSVR_CAST2(z), interior_only);    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(z));    IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_axpbypcz);    PetscFunctionReturn(0);} // VecAXPBYPCZ

PetscErrorCode VecMTDot_local_SAMRAI(Vec x, PetscInt nv, const Vec* y, PetscScalar* val){    IBTK_TIMER_START(t_vec_m_t_dot_local);#if !defined(NDEBUG)    TBOX_ASSERT(x);    for (PetscInt i = 0; i < nv; ++i)    {        TBOX_ASSERT(y[i]);    }#endif    static const bool local_only = true;    for (PetscInt i = 0; i < nv; ++i)    {        val[i] = PSVR_CAST2(x)->dot(PSVR_CAST2(y[i]), local_only);    }    IBTK_TIMER_STOP(t_vec_m_t_dot_local);    PetscFunctionReturn(0);} // VecMTDot_local

PetscErrorCodeVecPointwiseMult_SAMRAI(    Vec w,    Vec x,    Vec y){    IBTK_TIMER_START(t_vec_pointwise_mult);#ifdef DEBUG_CHECK_ASSERTIONS    TBOX_ASSERT(x != PETSC_NULL);    TBOX_ASSERT(y != PETSC_NULL);    TBOX_ASSERT(w != PETSC_NULL);#endif    static const bool interior_only = false;    PSVR_CAST2(w)->multiply(PSVR_CAST2(x), PSVR_CAST2(y), interior_only);    int ierr = PetscObjectStateIncrease(reinterpret_cast<PetscObject>(w)); IBTK_CHKERRQ(ierr);    IBTK_TIMER_STOP(t_vec_pointwise_mult);    PetscFunctionReturn(0);}// VecPointwiseMult