| version 1.1 | version 1.2 |
|---|
| |
| // Finish up, must be called after "done" is returned by addAtoms. | // Finish up, must be called after "done" is returned by addAtoms. |
| // Only the last thread that gets the "done" signal from addAtoms can enter here. | // Only the last thread that gets the "done" signal from addAtoms can enter here. |
| void finish() { | void finish() { |
| // Lock so that no thread can run addAtoms() between calls to finish() and clear() | |
| CmiLock(lock_); | |
| if (overflowEnd-overflowStart > 0) { | if (overflowEnd-overflowStart > 0) { |
| resize_((void **)&atom, numAtoms, atomCapacity, sizeof(CudaAtom)); | resize_((void **)&atom, numAtoms, atomCapacity, sizeof(CudaAtom)); |
| if (useIndex) resize_((void **)&atomIndex, numAtoms, atomIndexCapacity, sizeof(int)); | if (useIndex) resize_((void **)&atomIndex, numAtoms, atomIndexCapacity, sizeof(int)); |
| |
| void clear() { | void clear() { |
| patchPos.clear(); | patchPos.clear(); |
| numAtoms = 0; | numAtoms = 0; |
| // Unlock, OK to run addAtoms() again | |
| CmiUnlock(lock_); | |
| } | } |
| | |
| void lock() {CmiLock(lock_);} | |
| | |
| void unlock() {CmiUnlock(lock_);} | |
| | |
| // Return pointer to atom data | // Return pointer to atom data |
| CudaAtom* getAtoms() { | CudaAtom* getAtoms() { |
| return atom; | return atom; |
| |
| return atomIndex; | return atomIndex; |
| } | } |
| | |
| // // Setup estimate for number of atoms | |
| // void setupNumAtomsEstimate(int numAtomsEstimate) { | |
| // CmiLock(lock); | |
| // resize((void **)&atom, numAtomsEstimate, atomCapacity, sizeof(CudaAtom)); | |
| // CmiUnlock(lock); | |
| // } | |
| | |
| protected: | protected: |
| // Atom array | // Atom array |
| CudaAtom* atom; | CudaAtom* atom; |
| |
| | |
| // Resize array with 1.5x extra storage | // Resize array with 1.5x extra storage |
| void resize_(void **array, int sizeRequested, int& arrayCapacity, const int sizeofType) { | void resize_(void **array, int sizeRequested, int& arrayCapacity, const int sizeofType) { |
| const int oldSize = arrayCapacity; | // If array is not NULL and has enough capacity => we have nothing to do |
| void* old = NULL; | if (*array != NULL && arrayCapacity >= sizeRequested) return; |
| if (*array != NULL && arrayCapacity < sizeRequested) { | |
| old = alloc_(sizeofType*sizeRequested); | // Otherwise, allocate new array |
| memcpy_(old, *array, oldSize*sizeofType); | int newArrayCapacity = (int)(sizeRequested*1.5); |
| | void* newArray = alloc_(sizeofType*newArrayCapacity); |
| | |
| | if (*array != NULL) { |
| | // We have old array => copy contents to new array |
| | memcpy_(newArray, *array, arrayCapacity*sizeofType); |
| | // De-allocate old array |
| dealloc_(*array); | dealloc_(*array); |
| *array = NULL; | |
| } | |
| if (*array == NULL) { | |
| arrayCapacity = (int)(sizeRequested*1.5); | |
| *array = alloc_(sizeofType*arrayCapacity); | |
| if (old != NULL) { | |
| memcpy_(*array, old, oldSize*sizeofType); | |
| dealloc_(old); | |
| } | |
| } | } |
| | |
| | // Set new capacity and array pointer |
| | arrayCapacity = newArrayCapacity; |
| | *array = newArray; |
| } | } |
| | |
| virtual void memcpy_(void *dst, const void* src, const int size) { | virtual void memcpy_(void *dst, const void* src, const int size) { |