ClientSide.cc File Reference

#include <stdio.h>
#include <mpi.h>
#include "Schedule.h"
#include "DistributionBloc.h"
#include "Internal.h"
#include <vector>
#include <iostream>

Include dependency graph for ClientSide.cc:

Go to the source code of this file.

Functions
void	computeSendDataBlock1D (const GlobalData_t &gd, const LocalData_t &sd, const Topology_t &stopo, const Topology_t &dtopo, const ParisBlock_param_t *param, vAbstrait &vdarray, vector< unsigned > &destid, const PaCO::distLoc_t &mode, void *comm)
void	computeSendDataBlock1DClient (const GlobalData_t &gd, const LocalData_t &sd, const ParisBlock_param_t *param, const Topology_t &stopo, const Topology_t &dtopo, vAbstrait &vdarray, vector< unsigned > &destid, void *comm)
void	computeSendDataBlock1DComm ()
void	computeSendDataBlock1DServer (const GlobalData_t &gd, const LocalData_t &sd, const Topology_t &stopo, const Topology_t &dtopo, vAbstrait &vdarray, vector< unsigned > &destid)

Function Documentation

computeSendDataBlock1D()

void computeSendDataBlock1D	(	const GlobalData_t &	gd,
		const LocalData_t &	sd,
		const Topology_t &	stopo,
		const Topology_t &	dtopo,
		const ParisBlock_param_t *	param,
		vAbstrait &	vdarray,
		vector< unsigned > &	destid,
		const PaCO::distLoc_t &	mode,
		void *	comm
	)

Definition at line 215 of file ClientSide.cc.

References PaCO::ClientSide, PaCO::CommSide, computeSendDataBlock1DClient(), computeSendDataBlock1DComm(), computeSendDataBlock1DServer(), PaCO::none, and PaCO::ServerSide.

Referenced by ParisBlockMPC::computeSend(), BasicDistributionLibrary::computeSend(), ParisBlock::computeSend(), and doSchedule().

                                                    {

  switch(mode) {
  case PaCO::none: cerr << "INTERNAL ERROR: " << __FILE__ << " " << __FUNCTION__ << endl;
  case PaCO::ClientSide: computeSendDataBlock1DClient(gd, sd, param, stopo, dtopo, vdarray, destid, comm); break;
  case PaCO::ServerSide: computeSendDataBlock1DServer(gd, sd, stopo, dtopo, vdarray, destid); break;
  case PaCO::CommSide:   computeSendDataBlock1DComm  (); break;   
  }
  
}

Here is the call graph for this function:

computeSendDataBlock1DClient()

void computeSendDataBlock1DClient	(	const GlobalData_t &	gd,
		const LocalData_t &	sd,
		const ParisBlock_param_t *	param,
		const Topology_t &	stopo,
		const Topology_t &	dtopo,
		vAbstrait &	vdarray,
		vector< unsigned > &	destid,
		void *	comm
	)

Definition at line 29 of file ClientSide.cc.

References blockSize(), PaCO::ClientSide, computeBlockBoundInf(), computeReceiveBlock1D(), computeSendBlock1D(), dd, doSchedule(), PaCO::PacoLocalData_s::len, PaCO::PacoLocalData_s::rank, PaCO::PacoLocalData_s::start, and TotalNumberOfElementProc().

Referenced by computeSendDataBlock1D().

{

#ifdef DEBUG_INTERNAL
  cerr << "In computeSendDataBlock1DClient...\n";
#endif

  vector<LocalData_t> sched_send;
  vector<LocalData_t> sched_recv;

  sched_send.clear();
  sched_recv.clear();

  // Compute what to send
#ifdef DEBUG_INTERNAL
  cerr << "In computeSendDataBlock1DClient...computing what to send\n";
#endif
  computeSendBlock1D(gd, sd, stopo, dtopo, param, sched_send);

  // Compute what to receive
#ifdef DEBUG_INTERNAL
  cerr << "In computeSendDataBlock1DClient...computing what to receive\n";
#endif

  // compute how many dest local data this node has to handle
  unsigned int nvdarray  = dtopo.total/stopo.total;
  unsigned int remaining = (nvdarray*stopo.total + sd.rank < dtopo.total)?1:0;
  nvdarray += remaining;

  // Preparing also CORBA stuff
  vdarray.clear();
  vdarray.resize(nvdarray);
  destid.clear();
  destid.resize(nvdarray);

  // so, we simulate node from rank, rank+stopo.total ,... only if nvdarray>0
  unsigned dlbsz = blockSize(gd.len, dtopo.total, param); // blocsize on dest nodes
  // useless  unsigned dtbsz = NumberOfBlockProc(gd.len, dtopo.total , dlbsz, dtopo.total-1); // step on dest nodes
  
  //  cerr << "DBSZ: " << dbsz << endl;
  for (unsigned it=0; it<nvdarray; it++) {

#ifdef DEBUG_INTERNAL
    cerr << "computeSendDataBlock1DClient: it = " << it << endl;
#endif

    Abstrait* out = vdarray[it];

    out->topo().total   = dtopo.total;
    out->gd()           = gd;  // copy all global data struct

    // add for mode informations
    out->mode() = PaCO::ClientSide;

    out->dist().length(1);
    out->setSeqLength(1);

    PaCO::PacoLocalData_t& pld = out->dist()[0];
    LocalData_t dd;
    pld.rank  = dd.rank  = sd.rank + it * stopo.total;
    pld.start = dd.start = computeBlockBoundInf(dlbsz, dd.rank, dtopo.total, 0);
    pld.len   = dd.len   = TotalNumberOfElementProc(gd.len, dd.rank, dtopo.total, dlbsz);

#ifdef DEBUG_INTERNAL
    fprintf(stderr, "dd loop %d: r:%d gl:%ld ll:%d start:%d dt:%ld\n", it,
       dd.rank, gd.len, dd.len, dd.start, dtopo.total);
#endif

    destid[it] = dd.rank;

    // Allocating memory

#ifdef DEBUG_INTERNAL
    cerr << "Allocating a sequence of length " << pld.len << endl;
#endif
    out->setDataLength(0, pld.len);
    if (pld.len > 0 )
      dd.base = out->getDataBuffer(0, false);
    else
      dd.base = (char*) 1; /* hum, ... debug ;( */

    if (dd.base==0) {
      cerr << "Cannot allocate memory for #elements" << pld.len  << endl;
    } else {
#ifdef DEBUG_INTERNAL
      fprintf(stderr, "dd.base = %p\n", dd.base);
#endif
    }

    computeReceiveBlock1D(gd, dd, stopo, dtopo, param, sched_recv);
  }

  // Doing local communication
  //fprintf(stderr, "In computeSendDataBlock1DClient...Doing local communications with ctopo: %ld\n", dtopo.total);
  doSchedule(gd, sd, stopo, sched_send, sched_recv, comm); 

#ifdef DEBUG_INTERNAL
  cerr << "In computeSendDataBlock1DClient...ok\n";
#endif
}

Here is the call graph for this function:

computeSendDataBlock1DComm()

void computeSendDataBlock1DComm

(

)

Definition at line 208 of file ClientSide.cc.

Referenced by computeSendDataBlock1D().

                                  {
}

computeSendDataBlock1DServer()

void computeSendDataBlock1DServer	(	const GlobalData_t &	gd,
		const LocalData_t &	sd,
		const Topology_t &	stopo,
		const Topology_t &	dtopo,
		vAbstrait &	vdarray,
		vector< unsigned > &	destid
	)

Definition at line 156 of file ClientSide.cc.

References PaCO::ServerSide.

Referenced by computeSendDataBlock1D().

{


  // Easy: node i send data to node i%dtopo.total
  // It has to send an empty message to nodes i+stopo.total, i+2*stopo.total ... < dtopo.total

  // How messages to send ?
  unsigned int nvdarray  = dtopo.total/stopo.total;
  unsigned int remaining = (nvdarray*stopo.total + sd.rank < dtopo.total)?1:0;
  nvdarray += remaining;

  // alwaays something to send
  if ( nvdarray == 0 ) nvdarray=1;

  // Preparing  CORBA stuff
  vdarray.clear();
  vdarray.resize(nvdarray);
  destid.clear();
  destid.resize(nvdarray);

  for (unsigned it=0; it<nvdarray; it++) {

    Abstrait* out = vdarray[it];

    out->topo().total = stopo.total;
    out->gd()         = gd;
    
    // add for mode information
    out->mode() = PaCO::ServerSide;

    if ( it == 0 ) { // always data to send
      out->dist().length(1);
      out->setSeqLength(1);

      out->dist()[0].rank  = sd.rank;
      out->dist()[0].start = sd.start;
      out->dist()[0].len   = sd.len;
      out->DataReplace(0, sd.len, sd.base, false);
    } else { // always nothing to send
      out->dist().length(0);
      out->setSeqLength(0);
    }
    destid[it] = ( sd.rank + it * stopo.total ) % dtopo.total;
  }
}