Main Page Namespace List Class Hierarchy Alphabetical List Compound List File List Compound Members File Members
BoxLayout Class Reference
A not-necessarily disjoint collective of boxes.
More...
#include <BoxLayout.H>
Inheritance diagram for BoxLayout:
[legend]Collaboration diagram for BoxLayout:
[legend]List of all members.
Detailed Description
A not-necessarily disjoint collective of boxes.
A BoxLayout is a collection of Box objects that are assigned to a process number. Each box is associated with only one process. processes are numbered from 0 to n-1 (for an n process parallel job)
BoxLayout can be either open or closed. null construction or deepcopy creates an open BoxLayout. Boxes may be added to an open BoxLayout. non-const operations may be performed on the boxes existing in an open BoxLayout. closed BoxLayouts are sorted. Many uses of BoxLayouts require a closed BoxLayout. A closed BoxLayout cannot be modified.
Ref-counting ------------ BoxLayout is an explicitly ref-counted object.
Assignment and copy are compiler generated. They increment the refcount on the contained data members. They perform shallow, ref-counted operations.
Refcounting is a process whereby multiple instaniations make use of a single implementation of that object and keep a tally of how many instantiations are sharing. Thus
\begin{verbatim} BoxLayout b1(boxes, procIDs);
b1 ----> refcount = 1 ----> m_boxes ----> m_processors
BoxLayout b2(b1)
b1 ----> refcount = 2 <---- b2 ----> m_boxes <---- ----> m_processors <----
BoxLayout b3; b3 = b2;
b1 ----> refcount = 3 <---- b2 ----> m_boxes <---- ----> m_processors <---- ^^^ ||| b3 \end{verbatim}
Constructor & Destructor Documentation
| BoxLayout::BoxLayout |
( |
const Vector< Box > & |
a_boxes, |
|
|
const Vector< int > & |
a_procIDs |
|
) |
|
|
|
|
Construct from a Vector of Boxes and a Vector of processor assignments. On exit, the BoxLayout will be closed. |
| virtual BoxLayout::~BoxLayout |
( |
|
) |
[virtual] |
|
|
|
Ref-counted destruction. Once the last reference to the implementation of this class is destroyed, the data members are cleaned up |
Member Function Documentation
|
|
add a box to this BoxLayout. Takes the processor assignment. The input 'box' is copied. BoxLayout must be 'open' for this operation, otherwise a runtime error will occur. |
| bool BoxLayout::check |
( |
const LayoutIndex & |
index |
) |
const [inline] |
|
| virtual void BoxLayout::close |
( |
|
) |
[virtual] |
|
|
|
Mark this BoxLayout as complete and unchangeable.
Reimplemented in DisjointBoxLayout. |
| virtual void BoxLayout::deepCopy |
( |
const BoxLayout & |
a_source |
) |
[virtual] |
|
|
|
Actual deep copy operation. New object created with copied data. This object disassociates itself with original implementation safely. This object now is considered 'open' and can be non-const modified. There is no assurance that the order in which this BoxLayout is indexed corresponds to the indexing of a_source.
BoxLayout b1(boxes, procIDs); \begin{verbatim} b1 ----> refcount = 1 ----> m_boxes ----> m_processors
BoxLayout b2(b1)
b1 ----> refcount = 2 <---- b2 ----> m_boxes <---- ----> m_processors <----
BoxLayout b3; b3.deepCopy(b2); b1 ----> refcount = 2 <---- b2 b3 ----> refcount = 1 ----> m_boxes <---- ----> m_boxes ----> m_processors <---- ----> m_processors \end{verbatim}
Reimplemented in DisjointBoxLayout. |
| virtual void BoxLayout::define |
( |
const Vector< Box > & |
a_boxes, |
|
|
const Vector< int > & |
a_procIDs |
|
) |
[virtual] |
|
|
|
Define this BoxLayout from a Vector of Boxes and a Vector of processor assignments. Any pre-existing layout will be lost (ref-count dropped by one). The processor assignment Vector must be the same length as the Box Vector. On exit, the BoxLayout will be closed.
Reimplemented in DisjointBoxLayout. |
| bool BoxLayout::eq |
( |
const BoxLayout & |
rhs |
) |
const [inline] |
|
|
|
As a consquence of the C++ compiler being free to choose which version of operator[] when the object is technically non-const, we very often get 'BoxLayout closed' errors. This is a non-overloaded get method. |
| unsigned int BoxLayout::index |
( |
const LayoutIndex & |
index |
) |
const [inline] |
|
| bool BoxLayout::isClosed |
( |
|
) |
const [inline] |
|
|
|
return true if close() has been called. closed BoxLayout is always sorted. |
| bool BoxLayout::isSorted |
( |
|
) |
const [inline] |
|
|
|
return true if sort() has been called |
|
|
If BoxLayout is closed, then LayoutIterator will return the Box's in sorted order. Processes through ALL the boxes in a BoxLayout |
| int BoxLayout::numBoxes |
( |
const int |
procID |
) |
const |
|
| BoxLayout& BoxLayout::operator= |
( |
const BoxLayout & |
a_rhs |
) |
|
|
| bool BoxLayout::operator== |
( |
const BoxLayout & |
rhs |
) |
const [inline] |
|
|
|
Refcounted pointer check. True if these two objects share the same implementation. |
| const Box & BoxLayout::operator[] |
( |
const LayoutIndex & |
it |
) |
const [inline] |
|
|
|
const accessor operator. see also {\tt get(const DataIndex&)} |
| void BoxLayout::p |
( |
|
) |
const [inline] |
|
| void BoxLayout::print |
( |
|
) |
const |
|
| unsigned int BoxLayout::procID |
( |
const LayoutIndex & |
a_index |
) |
const [inline] |
|
|
|
Returns the processor to which this box has been assigned. Not a user function, at least, not a new user function. It can be used safely at anytime, closed or open. A person needing this level of knowledge of the processor assignment should have non-trivial needs, like writing your own load balancer or such. Most user level parallel coding needs can be addressed using the DataIterator class. |
| void BoxLayout::setIndexVector |
( |
|
) |
[protected] |
|
| void BoxLayout::setProcID |
( |
const LayoutIndex & |
a_index, |
|
|
unsigned int |
a_procID |
|
) |
[inline] |
|
|
|
Assign a Box in the BoxLayout to a processor. Requires the BoxLayout to be open. |
| unsigned int BoxLayout::size |
( |
|
) |
const [inline] |
|
Friends And Related Function Documentation
| void coarsen |
( |
BoxLayout & |
output, |
|
|
const BoxLayout & |
input, |
|
|
int |
refinement |
|
) |
[friend] |
|
|
|
'output' must be open, 'input' must be closed, 'refinement' must be a positive non-zero integer. 'output' and 'input' do not share an implementation. 'output' is first deepcopy'ed from 'input', then coarsen(refinement) is called on each box of 'output'. 'output' returns from this function closed. LayoutIterators from 'input' and 'output' can perform interchangeably. |
friend class DataIterator [friend]
|
|
friend class LayoutIterator [friend]
|
|
| void refine |
( |
BoxLayout & |
output, |
|
|
const BoxLayout & |
input, |
|
|
int |
refinement |
|
) |
[friend] |
|
|
|
see 'coarsen ' and substitute the word "refine" for "coarsen" |
Member Data Documentation
The documentation for this class was generated from the following file:
Generated on Wed Apr 16 14:35:03 2003 for EBChombo by
1.2.16