1: /*
  2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
  4:    Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain

  6:    This file is part of SLEPc.
  7:    SLEPc is distributed under a 2-clause BSD license (see LICENSE).
  8:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  9: */
 10: /*
 11:    Implementation of a pool of Vec using VecDuplicateVecs
 12: */

 14: #include <slepc/private/vecimplslepc.h>

 16: /*
 17:    SlepcVecPoolCreate - Create a pool of Vec.

 19:    Collective

 21:    Input Parameters:
 22: +  v - template vector.
 23: -  init_size - first guess of maximum vectors.

 25:    Output Parameter:
 26: .  p - the pool context.

 28:    Level: developer

 30: .seealso: SlepcVecPoolGetVecs(), SlepcVecPoolDestroy()
 31: */
 32: PetscErrorCode SlepcVecPoolCreate(Vec v,PetscInt init_size,VecPool *p)
 33: {
 34:   VecPool_       *pool;

 36:   PetscFunctionBegin;
 39:   PetscAssertPointer(p,3);
 40:   PetscCheck(init_size>=0,PetscObjectComm((PetscObject)v),PETSC_ERR_ARG_WRONG,"init_size should be positive");
 41:   PetscCall(PetscCalloc1(1,&pool));
 42:   PetscCall(PetscObjectReference((PetscObject)v));
 43:   pool->v     = v;
 44:   pool->guess = init_size;
 45:   *p = pool;
 46:   PetscFunctionReturn(PETSC_SUCCESS);
 47: }

 49: /*
 50:    SlepcVecPoolDestroy - Destroy the pool of Vec.

 52:    Collective

 54:    Input Parameters:
 55: .  p - pool of Vec.

 57:    Level: developer

 59: .seealso: SlepcVecPoolGetVecs(), SlepcVecPoolCreate()
 60: */
 61: PetscErrorCode SlepcVecPoolDestroy(VecPool *p)
 62: {
 63:   VecPool_       *pool = (VecPool_*)*p;

 65:   PetscFunctionBegin;
 66:   if (!*p) PetscFunctionReturn(PETSC_SUCCESS);
 67:   PetscCall(VecDestroy(&pool->v));
 68:   PetscCall(VecDestroyVecs(pool->n,&pool->vecs));
 69:   pool->n     = 0;
 70:   pool->used  = 0;
 71:   pool->guess = 0;
 72:   PetscCall(SlepcVecPoolDestroy((VecPool*)&pool->next));
 73:   PetscCall(PetscFree(pool));
 74:   *p = NULL;
 75:   PetscFunctionReturn(PETSC_SUCCESS);
 76: }

 78: /*
 79:    SlepcVecPoolGetVecs - Get an array of Vec from the pool.

 81:    Collective

 83:    Input Parameters:
 84: +  p - pool of Vec.
 85: -  n - number of vectors.

 87:    Output Parameter:
 88: .  vecs - vectors

 90:    Level: developer

 92: .seealso: SlepcVecPoolRestoreVecs()
 93: */
 94: PetscErrorCode SlepcVecPoolGetVecs(VecPool p,PetscInt n,Vec **vecs)
 95: {
 96:   VecPool_       *pool = (VecPool_*)p;

 98:   PetscFunctionBegin;
 99:   PetscAssertPointer(p,1);
100:   PetscAssertPointer(vecs,3);
101:   PetscCheck(n>=0,PetscObjectComm((PetscObject)pool->v),PETSC_ERR_ARG_OUTOFRANGE,"n should be positive");
102:   while (pool->next) pool = pool->next;
103:   if (pool->n-pool->used < n) {
104:     pool->guess = PetscMax(p->guess,pool->used+n);
105:     if (pool->vecs && pool->used == 0) PetscCall(VecDestroyVecs(pool->n,&pool->vecs));
106:     if (pool->vecs) {
107:       PetscCall(SlepcVecPoolCreate(p->v,pool->guess-pool->used,&pool->next));
108:       pool = pool->next;
109:     }
110:     pool->n = pool->guess;
111:     PetscCall(VecDuplicateVecs(p->v,pool->n,&pool->vecs));
112:   }
113:   *vecs = pool->vecs + pool->used;
114:   pool->used += n;
115:   PetscFunctionReturn(PETSC_SUCCESS);
116: }

118: /*
119:    SlepcVecPoolRestoreVecs - Get back an array of Vec previously returned by
120:    SlepcVecPoolGetVecs().

122:    Collective

124:    Input Parameters:
125: +  p    - pool of Vec.
126: .  n    - number of vectors.
127: -  vecs - vectors

129:    Level: developer

131: .seealso: SlepcVecPoolGetVecs()
132: */
133: PetscErrorCode SlepcVecPoolRestoreVecs(VecPool p,PetscInt n,Vec **vecs)
134: {
135:   VecPool_       *pool = (VecPool_*)p, *pool0 = pool;

137:   PetscFunctionBegin;
138:   while (pool->next) pool = (pool0 = pool)->next;
139:   if (pool->used == 0 && pool0 != pool) {
140:     pool0->guess = pool0->used + pool->guess;
141:     PetscCall(SlepcVecPoolDestroy((VecPool*)&pool));
142:     pool = pool0;
143:     pool->next = NULL;
144:   }
145:   pool->used -= n;
146:   PetscCheck(pool->used>=0,PetscObjectComm((PetscObject)pool->v),PETSC_ERR_ARG_OUTOFRANGE,"Unmatched SlepcVecPoolRestoreVecs");
147:   PetscFunctionReturn(PETSC_SUCCESS);
148: }