par::step::query_reply< E > Class Template Reference
[Dispatching large amounts of information]

This implements an extension of bulk that allows to imediately send back as much information as one receives. More...

#include <par_step_query_reply.h>

Inheritance diagram for par::step::query_reply< E >:

Inheritance graph
[legend]
Collaboration diagram for par::step::query_reply< E >:

Collaboration graph
[legend]

List of all members.

Public Types

typedef bulk< E >::S S
 The source type of the bulk communication.
typedef bulk< E >::T T
 The target type of the bulk communication.

Public Member Functions

void count (void)
template<class iterator >
void count (iterator &act)
void distribute (void)
void extraction (mem::chunk< T > *&buf)
template<class iterator >
void extraction (iterator &act, mem::chunk< T > *&buf)
void finish (void)
 do eventual clean up.
template<class iterator >
void finish (iterator &act)
void force_next_round (void) const
proc_data & get_context (void) const
proc_data_p get_local (void) const
 Get more detailed information about this parXXL process.
off_t get_messageLength () const
FILE * get_out (void) const
off_t get_receivLength () const
int get_round (void) const
int get_tag (void) const
mem::chunk< void > & getRecv (proc_t w) const
 The par::mem:chunk< void > that is to be received in this superstep from process w.
mem::chunk< void > * getRecvs (void) const
mem::chunk< void > & getSend (proc_t w) const
 The par::mem:chunk< void > that is to be sent in this superstep to process w.
mem::chunk< void > * getSends (void) const
par::cntrl::proc_t mynum (void) const
 The id of this particular parXXL process.
par::cntrl::proc_t np (void) const
 The number of parXXL processes in this parXXL run.
par::cntrl::proc_t np1 (void) const
 The number of parXXL processes plus one in this parXXL run.
par::cntrl::proc_t npm1 (void) const
 The number of parXXL processes minus one in this parXXL run.
void pop_state (void)
void push_state (unsigned salt)
void query (void)
template<class iterator >
void query (iterator &act)
 query_reply (bulk_generic const &other, array< S > &gga, E &extr)
 query_reply (bulk_generic const &other, array< S > &gga)
 query_reply (array< S > &gga, E &extr)
void re_extraction (mem::chunk< T > *&buf)
template<class iterator >
void re_extraction (iterator &act, mem::chunk< T > *&buf)
void reply (void)
template<class iterator >
void reply (iterator &act)
void set_out (FILE *of=NULL)
bool valid (long const proc) const
bool valid (ulong const proc) const
bool valid (int const proc) const
bool valid (unsigned const proc) const
Setting and getting target array.
After a call to bulk::set_recvarray() the target array will not be destructed upon the destruction of this bulk. Have a look into sorting::redistribute to see how this function can be used.

If the target array is constructed implicitly and you use bulk::get_recvarray() to receive its address, this reference is only valid as long as the bulk is not destructed.

void allocate ()
 Force allocation and dimensioning of the target array.
array< T > * get_recvarray (void) const
mem::chunk< T > & get_recvchunk (par::cntrl::proc_t whom)
void set_recvarray (array< T > &ra)
void set_recvarray (array< T > *ra=NULL)
Allocation
More sofisticated user interfaces.

Allocate and deallocate the received buffer This will depend on the model of parallelism that we use.

void deallocate (void)
void deallocate_data (void)
 this will not be done automatically on destruction
The primary user interfaces
template<class iterator >
void exchange (iterator &act, bool delsource=false)
void exchange (bool delsource=false)
 Do the real exchange of the data.
template<class iterator >
void initiate (iterator &act)
void initiate (void)
 Initialize the buffers.

Static Public Member Functions

static void static_init (void)

Public Attributes

iterator active
par::step::array< S > & datarray
 The source array of the bulk communication.
E & extractor
 specify the kind of communication.
off_t global
off_t *const total

Protected Attributes

cntrl::matrix< off_texch
off_t *const messageNo
off_t messageSize
off_t const nb_elts
bool own_recv
 Whether recvarray has been allocated by this bulk.
par::mem::chunk< T > * rchunks
 A table of received chunks per source processor.
par::cntrl::proc_t receive_expected
par::cntrl::proc_t receive_expected_here
off_t receiveSize
off_t *const receivNo
par::step::array< T > * recvarray
 The array that receives the data.


Detailed Description

template<class E>
class par::step::query_reply< E >

This implements an extension of bulk that allows to imediately send back as much information as one receives.

Definition at line 33 of file par_step_query_reply.h.


Member Typedef Documentation

template<class E>
typedef bulk< E >::S par::step::query_reply< E >::S

The source type of the bulk communication.

Reimplemented from par::step::bulk< E >.

Definition at line 36 of file par_step_query_reply.h.

template<class E>
typedef bulk< E >::T par::step::query_reply< E >::T

The target type of the bulk communication.

Reimplemented from par::step::bulk< E >.

Definition at line 37 of file par_step_query_reply.h.


Constructor & Destructor Documentation

template<class E>
par::step::query_reply< E >::query_reply ( array< S > &  gga,
E &  extr 
) [inline]

Definition at line 57 of file par_step_query_reply.h.

template<class E>
par::step::query_reply< E >::query_reply ( bulk_generic const &  other,
array< S > &  gga 
) [inline]

Definition at line 62 of file par_step_query_reply.h.

template<class E>
par::step::query_reply< E >::query_reply ( bulk_generic const &  other,
array< S > &  gga,
E &  extr 
) [inline]

Definition at line 66 of file par_step_query_reply.h.


Member Function Documentation

template<class E>
void par::step::bulk< E >::allocate ( void   )  [inline, inherited]

Force allocation and dimensioning of the target array.

As a result the local part of the is at the correct length and the target array knows about the lengths on the other processors.

Definition at line 210 of file par_step_bulk.h.

template<class E>
void par::step::bulk< E >::count ( void   )  [inline, inherited]

Definition at line 138 of file par_step_bulk.h.

template<class E >
template<class iterator >
template void par::step::bulk< E >::count< iterator > ( iterator act  )  [inline, inherited]

Definition at line 35 of file par_step_bulk.cc.

template<class E >
void par::step::bulk< E >::deallocate ( void   )  [inline, inherited]

Definition at line 142 of file par_step_bulk.cc.

template<class E >
void par::step::bulk< E >::deallocate_data ( void   )  [inline, inherited]

this will not be done automatically on destruction

Definition at line 159 of file par_step_bulk.cc.

void par::step::bulk_generic::distribute ( void   )  [inherited]

propagate and collect the number of elements that we will send form each to each other parXXL process.

Definition at line 32 of file par_step_bulk_generic.cc.

template<class E >
template<class iterator >
template void par::step::bulk< E >::exchange< iterator > ( iterator act,
bool  delsource = false 
) [inline, inherited]

Definition at line 128 of file par_step_bulk.cc.

template<class E>
void par::step::bulk< E >::exchange ( bool  delsource = false  )  [inline, inherited]

Do the real exchange of the data.

Parameters:
delsource if means that the source array may be deleted as soon as the data savely sits in some buffer or has arrived at the other side.

Definition at line 245 of file par_step_bulk.h.

template<class E>
void par::step::bulk< E >::extraction ( mem::chunk< T > *&  buf  )  [inline, inherited]

Definition at line 143 of file par_step_bulk.h.

template<class E >
template<class iterator >
template void par::step::bulk< E >::extraction< iterator > ( iterator act,
mem::chunk< T > *&  buf 
) [inline, inherited]

Definition at line 69 of file par_step_bulk.cc.

template<class E>
void par::step::query_reply< E >::finish ( void   )  [inline]

do eventual clean up.

Reimplemented from par::step::bulk< E >.

Definition at line 55 of file par_step_query_reply.h.

template<class E >
template<class iterator >
void par::step::query_reply< E >::finish ( iterator act  )  [inline]

Reimplemented from par::step::bulk< E >.

Definition at line 107 of file par_step_query_reply.cc.

off_t par::step::bulk_generic::get_messageLength (  )  const [inline, inherited]

Definition at line 109 of file par_step_bulk_generic.h.

off_t par::step::bulk_generic::get_receivLength (  )  const [inline, inherited]

Definition at line 110 of file par_step_bulk_generic.h.

template<class E>
array< T >* par::step::bulk< E >::get_recvarray ( void   )  const [inline, inherited]

Definition at line 196 of file par_step_bulk.h.

template<class E>
mem::chunk< T >& par::step::bulk< E >::get_recvchunk ( par::cntrl::proc_t  whom  )  [inline, inherited]

Definition at line 200 of file par_step_bulk.h.

template<class E >
template<class iterator >
template void par::step::bulk< E >::initiate< iterator > ( iterator act  )  [inline, inherited]

Definition at line 120 of file par_step_bulk.cc.

template<class E>
void par::step::bulk< E >::initiate ( void   )  [inline, inherited]

Initialize the buffers.

Definition at line 234 of file par_step_bulk.h.

template<class E>
void par::step::query_reply< E >::query ( void   )  [inline]

Definition at line 52 of file par_step_query_reply.h.

template<class E >
template<class iterator >
void par::step::query_reply< E >::query ( iterator act  )  [inline]

Definition at line 88 of file par_step_query_reply.cc.

template<class E>
void par::step::query_reply< E >::re_extraction ( mem::chunk< T > *&  buf  )  [inline]

Definition at line 54 of file par_step_query_reply.h.

template<class E >
template<class iterator >
void par::step::query_reply< E >::re_extraction ( iterator act,
mem::chunk< T > *&  buf 
) [inline]

Definition at line 36 of file par_step_query_reply.cc.

template<class E>
void par::step::query_reply< E >::reply ( void   )  [inline]

Definition at line 53 of file par_step_query_reply.h.

template<class E >
template<class iterator >
void par::step::query_reply< E >::reply ( iterator act  )  [inline]

Definition at line 94 of file par_step_query_reply.cc.

template<class E>
void par::step::bulk< E >::set_recvarray ( array< T > &  ra  )  [inline, inherited]

Definition at line 194 of file par_step_bulk.h.

template<class E>
void par::step::bulk< E >::set_recvarray ( array< T > *  ra = NULL  )  [inline, inherited]

Definition at line 189 of file par_step_bulk.h.

static void par::cntrl::info::static_init ( void   )  [static, inherited]


Member Data Documentation

Definition at line 103 of file par_step_bulk_generic.h.

template<class E>
par::step::array< S >& par::step::bulk< E >::datarray [inherited]

The source array of the bulk communication.

Definition at line 128 of file par_step_bulk.h.

Definition at line 81 of file par_step_bulk_generic.h.

template<class E>
E& par::step::bulk< E >::extractor [inherited]

specify the kind of communication.

The extractor that allows the programmer to

Definition at line 119 of file par_step_bulk.h.

Definition at line 101 of file par_step_bulk_generic.h.

off_t* const par::step::bulk_generic::messageNo [protected, inherited]

bulk will count the amount of messages to be send to each parXXL process. The result will be reflected in an array of size np() named messageNo. individual parXXL process.

Definition at line 79 of file par_step_bulk_generic.h.

Definition at line 80 of file par_step_bulk_generic.h.

off_t const par::step::bulk_generic::nb_elts [protected, inherited]

Definition at line 93 of file par_step_bulk_generic.h.

template<class E>
bool par::step::bulk< E >::own_recv [protected, inherited]

Whether recvarray has been allocated by this bulk.

Definition at line 124 of file par_step_bulk.h.

template<class E>
par::mem::chunk< T >* par::step::bulk< E >::rchunks [protected, inherited]

A table of received chunks per source processor.

Definition at line 125 of file par_step_bulk.h.

Definition at line 94 of file par_step_bulk_generic.h.

Definition at line 95 of file par_step_bulk_generic.h.

Definition at line 92 of file par_step_bulk_generic.h.

off_t* const par::step::bulk_generic::receivNo [protected, inherited]

Definition at line 91 of file par_step_bulk_generic.h.

template<class E>
par::step::array< T >* par::step::bulk< E >::recvarray [protected, inherited]

The array that receives the data.

Definition at line 123 of file par_step_bulk.h.

This table can be used to propagate controling information to all other parXXL processes.

Definition at line 100 of file par_step_bulk_generic.h.


The documentation for this class was generated from the following files:

Generated on Tue Oct 13 22:04:24 2009 for parXXL by  doxygen 1.5.8