/* ** CXSC is a C++ library for eXtended Scientific Computing ** ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik, ** Universitaet Karlsruhe, Germany ** (C) 2000-2006 Wiss. Rechnen/Softwaretechnologie ** Universitaet Wuppertal, Germany ** ** This library is free software; you can redistribute it and/or ** modify it under the terms of the GNU Library General Public ** License as published by the Free Software Foundation; either ** version 2 of the License, or (at your option) any later version. ** ** This library is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ** Library General Public License for more details. ** ** You should have received a copy of the GNU Library General Public ** License along with this library; if not, write to the Free ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MPI-Routines for C-XSC data types // "Packed" version: Sends data in Packed format // // Author: Markus Grimmer // Date: 5.3.2006 // // Incorporated Data Types: real, interval, rvector, ivector, rmatrix, imatrix, // complex, cinterval, cvector, civector, cmatrix, cimatrix, // l_real, l_interval, l_complex, // l_rvector, l_ivector, l_rmatrix, l_imatrix, // dotprecision, idotprecision, // cdotprecision, cidotprecision // Incorporated Communication Routines: MPI_Send, MPI_Isend, // MPI_Recv #include "cxsc_mpicomm.h" using namespace cxsc; using namespace std; bool MPI_CXSC_TYPES_DEFINED=false; MPI_Datatype MPI_CXSC_REAL; MPI_Datatype MPI_CXSC_COMPLEX; MPI_Datatype MPI_CXSC_INTERVAL; MPI_Datatype MPI_CXSC_CINTERVAL; // Definition of new MPI data types: int MPI_Define_CXSC_Types() { int err; if (err=MPI_Type_contiguous(1,MPI_DOUBLE,&MPI_CXSC_REAL)!=MPI_SUCCESS) return err; if (err=MPI_Type_commit(&MPI_CXSC_REAL)!=MPI_SUCCESS) return err; if (err=MPI_Type_contiguous(2,MPI_CXSC_REAL,&MPI_CXSC_COMPLEX)!=MPI_SUCCESS) return err; if (err=MPI_Type_commit(&MPI_CXSC_COMPLEX)!=MPI_SUCCESS) return err; if (err=MPI_Type_contiguous(2,MPI_CXSC_REAL,&MPI_CXSC_INTERVAL)!=MPI_SUCCESS) return err; if (err=MPI_Type_commit(&MPI_CXSC_INTERVAL)!=MPI_SUCCESS) return err; if (err=MPI_Type_contiguous(2,MPI_CXSC_INTERVAL,&MPI_CXSC_CINTERVAL)!=MPI_SUCCESS) return err; if (err=MPI_Type_commit(&MPI_CXSC_CINTERVAL)!=MPI_SUCCESS) return err; MPI_CXSC_TYPES_DEFINED=true; return err; } // ============================================================================= // // Scalar data types // // ============================================================================= // ============================================================================= // MPI-Send/Recv for real: // ============================================================================= int MPI_Send (real& r, int i1, int i2, MPI_Comm MC) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Send(&r,1,MPI_CXSC_REAL,i1,i2,MC); return err; } int MPI_Isend (real& r, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Isend(&r,1,MPI_CXSC_REAL,i1,i2,MC,MR); return err; } int MPI_Recv (real& r, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Recv(&r,1,MPI_CXSC_REAL,i1,i2,MC,MS); return err; } // ============================================================================= // MPI-Send/Recv for complex: // ============================================================================= int MPI_Send (complex& c, int i1, int i2, MPI_Comm MC) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Send(&c,1,MPI_CXSC_COMPLEX,i1,i2,MC); return err; } int MPI_Isend (complex& c, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Isend(&c,1,MPI_CXSC_COMPLEX,i1,i2,MC,MR); return err; } int MPI_Recv (complex& c, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Recv(&c,1,MPI_CXSC_COMPLEX,i1,i2,MC,MS); return err; } // ============================================================================= // MPI-Send/Recv for interval: // ============================================================================= int MPI_Send (interval& ri, int i1, int i2, MPI_Comm MC) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Send(&ri,1,MPI_CXSC_INTERVAL,i1,i2,MC); return err; } int MPI_Isend (interval& ri, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Isend(&ri,1,MPI_CXSC_INTERVAL,i1,i2,MC,MR); return err; } int MPI_Recv (interval& ri, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Recv(&ri,1,MPI_CXSC_INTERVAL,i1,i2,MC,MS); return err; } // ============================================================================= // MPI-Send/Recv for cinterval: // ============================================================================= int MPI_Send (cinterval& ci, int i1, int i2, MPI_Comm MC) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Send(&ci,1,MPI_CXSC_CINTERVAL,i1,i2,MC); return err; } int MPI_Isend (cinterval& ci, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Isend(&ci,1,MPI_CXSC_CINTERVAL,i1,i2,MC,MR); return err; } int MPI_Recv (cinterval& ci, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; err=MPI_Recv(&ci,1,MPI_CXSC_CINTERVAL,i1,i2,MC,MS); return err; } // ============================================================================= // // Multiple precision data types (Scalar values) // // ============================================================================= // ============================================================================= // MPI-Send/Recv for l_real: // ============================================================================= int MPI_Send(l_real& l_r, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int prec=StagPrec(l_r); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_r[1],prec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(l_real& l_r, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int prec=StagPrec(l_r); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_r[1],prec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(l_real& l_r, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int lrprec; int stagprectmp; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lrprec, 1, MPI_INT, MC); // Temporarily change stagprec to declare a new variable with the received // precision: stagprectmp=stagprec; stagprec=lrprec; l_real lr_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lr_temp[1], lrprec, MPI_CXSC_REAL, MC); l_r=lr_temp; return err; } // ============================================================================= // MPI-Send/Recv for l_interval: // ============================================================================= int MPI_Send(l_interval& l_i, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int prec=StagPrec(l_i); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_i[1],prec+1,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(l_interval& l_i, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int prec=StagPrec(l_i); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_i[1],prec+1,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(l_interval& l_i, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int liprec; int stagprectmp; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &liprec, 1, MPI_INT, MC); // Temporarily change stagprec to declare a new variable with the received // precision: stagprectmp=stagprec; stagprec=liprec; l_interval li_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &li_temp[1], liprec+1, MPI_CXSC_REAL, MC); l_i=li_temp; return err; } // ============================================================================= // MPI-Send/Recv for l_complex: // ============================================================================= int MPI_Send(l_complex& l_c, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int reprec=StagPrec(Re(l_c)); int imprec=StagPrec(Im(l_c)); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&reprec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&(Re(l_c)[1]),reprec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&imprec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&(Im(l_c)[1]),imprec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(l_complex& l_c, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int reprec=StagPrec(Re(l_c)); int imprec=StagPrec(Im(l_c)); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&reprec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&(Re(l_c)[1]),reprec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&imprec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&(Im(l_c)[1]),imprec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(l_complex& l_c, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int reprec,imprec; int stagprectmp; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &reprec, 1, MPI_INT, MC); // Temporarily change stagprec to declare a new variable with the received // precision for re: stagprectmp=stagprec; stagprec=reprec; l_real re_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &re_temp[1], reprec, MPI_CXSC_REAL, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &imprec, 1, MPI_INT, MC); // Temporarily change stagprec to declare a new variable with the received // precision for im: stagprectmp=stagprec; stagprec=imprec; l_real im_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &im_temp[1], imprec, MPI_CXSC_REAL, MC); Re(l_c)=re_temp; Im(l_c)=im_temp; return err; } // ============================================================================= // // Vector data types // // ============================================================================= // ============================================================================= // MPI-Send/Recv for rvector: // ============================================================================= int MPI_Send(rvector& rv, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(rv); int ub=Ub(rv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&rv[lb],ub-lb+1,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(rvector& rv, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(rv); int ub=Ub(rv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&rv[lb],ub-lb,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(rvector& rv, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int vlen, lb, ub; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub, 1, MPI_INT, MC); vlen=ub-lb+1; Resize(rv,vlen); SetLb(rv,lb); //rv.SetUb(ub); // Should not be necessary, you can try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &rv[lb] , vlen, MPI_CXSC_REAL, MC); return err; } // ============================================================================= // MPI-Send/Recv for cvector: // ============================================================================= int MPI_Send(cvector& cv, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(cv); int ub=Ub(cv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&cv[lb],ub-lb+1,MPI_CXSC_COMPLEX,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(cvector& cv, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(cv); int ub=Ub(cv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&cv[lb],ub-lb,MPI_CXSC_COMPLEX,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(cvector& cv, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int vlen, lb, ub; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub, 1, MPI_INT, MC); vlen=ub-lb+1; Resize(cv,vlen); SetLb(cv,lb); //cv.SetUb(ub); // Should not be necessary, you can try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &cv[lb] , vlen, MPI_CXSC_COMPLEX, MC); return err; } // ============================================================================= // MPI-Send/Recv for ivector: // ============================================================================= int MPI_Send(ivector& iv, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(iv); int ub=Ub(iv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&iv[lb],ub-lb+1,MPI_CXSC_INTERVAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(ivector& iv, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(iv); int ub=Ub(iv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&iv[lb],ub-lb,MPI_CXSC_INTERVAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(ivector& iv, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int vlen, lb, ub; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub, 1, MPI_INT, MC); vlen=ub-lb+1; Resize(iv,vlen); SetLb(iv,lb); //iv.SetUb(ub); // Should not be necessary, you can try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &iv[lb] , vlen, MPI_CXSC_INTERVAL, MC); return err; } // ============================================================================= // MPI-Send/Recv for civector: // ============================================================================= int MPI_Send(civector& civ, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(civ); int ub=Ub(civ); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&civ[lb],ub-lb+1,MPI_CXSC_CINTERVAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(civector& civ, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(civ); int ub=Ub(civ); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&civ[lb],ub-lb,MPI_CXSC_CINTERVAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(civector& civ, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int vlen, lb, ub; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub, 1, MPI_INT, MC); vlen=ub-lb+1; Resize(civ,vlen); SetLb(civ,lb); //civ.SetUb(ub); // Should not be necessary, you can try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &civ[lb] , vlen, MPI_CXSC_CINTERVAL, MC); return err; } // ============================================================================= // // Multiple precision data types (Vectors) // // ============================================================================= // ============================================================================= // MPI-Send/Recv for l_rvector: // ============================================================================= int MPI_Send(l_rvector& l_rv, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(l_rv); int ub=Ub(l_rv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb;i<=ub;i++) { int prec=StagPrec(l_rv[i]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_rv[i][1],prec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(l_rvector& l_rv, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(l_rv); int ub=Ub(l_rv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb;i<=ub;i++) { int prec=StagPrec(l_rv[i]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_rv[i][1],prec,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(l_rvector& l_rv, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int vlen, lb, ub; int stagprectmp; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub, 1, MPI_INT, MC); vlen=ub-lb+1; Resize(l_rv,vlen); SetLb(l_rv,lb); //l_rv.SetUb(ub); // Should not be necessary, you can try it for test purposes for (int i=lb; i<=ub; i++) { int lrprec; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lrprec, 1, MPI_INT, MC); stagprectmp=stagprec; stagprec=lrprec; l_real lr_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lr_temp[1], lrprec, MPI_CXSC_REAL, MC); l_rv[i]=lr_temp; } return err; } // ============================================================================= // MPI-Send/Recv for l_ivector: // ============================================================================= int MPI_Send(l_ivector& l_iv, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(l_iv); int ub=Ub(l_iv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb;i<=ub;i++) { int prec=StagPrec(l_iv[i]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_iv[i][1],prec+1,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(l_ivector& l_iv, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb=Lb(l_iv); int ub=Ub(l_iv); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb;i<=ub;i++) { int prec=StagPrec(l_iv[i]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_iv[i][1],prec+1,MPI_CXSC_REAL,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(l_ivector& l_iv, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int vlen, lb, ub; int stagprectmp; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub, 1, MPI_INT, MC); vlen=ub-lb+1; Resize(l_iv,vlen); SetLb(l_iv,lb); //l_iv.SetUb(ub); // Should not be necessary, you can try it for test purposes for (int i=lb; i<=ub; i++) { int liprec; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &liprec, 1, MPI_INT, MC); stagprectmp=stagprec; stagprec=liprec; l_interval li_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &li_temp[1], liprec+1, MPI_CXSC_REAL, MC); l_iv[i]=li_temp; } return err; } // ============================================================================= // // Matrix data types // // ============================================================================= // ============================================================================= // MPI-Send/Recv for rmatrix: // ============================================================================= int MPI_Send(rmatrix& rm, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(rm,1); int lb2=Lb(rm,2); int ub1=Ub(rm,1); int ub2=Ub(rm,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&rm[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_REAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(rmatrix& rm, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(rm,1); int lb2=Lb(rm,2); int ub1=Ub(rm,1); int ub2=Ub(rm,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&rm[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_REAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(rmatrix& rm, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int mlen1, mlen2, lb1, ub1, lb2, ub2; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb2, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub2, 1, MPI_INT, MC); mlen1=ub1-lb1+1; mlen2=ub2-lb2+1; Resize(rm,mlen1,mlen2); SetLb(rm,1,lb1); SetLb(rm,2,lb2); //SetUb(rm,1,ub1); // Should not be necessary - try it for test purposes //SetUb(rm,2,ub2); // Should not be necessary - try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &rm[lb1][lb2], mlen1*mlen2, MPI_CXSC_REAL, MC); return err; } // ============================================================================= // MPI-Send/Recv for cmatrix: // ============================================================================= int MPI_Send(cmatrix& cm, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(cm,1); int lb2=Lb(cm,2); int ub1=Ub(cm,1); int ub2=Ub(cm,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&cm[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_COMPLEX,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(cmatrix& cm, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(cm,1); int lb2=Lb(cm,2); int ub1=Ub(cm,1); int ub2=Ub(cm,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&cm[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_COMPLEX,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(cmatrix& cm, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int mlen1, mlen2, lb1, ub1, lb2, ub2; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb2, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub2, 1, MPI_INT, MC); mlen1=ub1-lb1+1; mlen2=ub2-lb2+1; Resize(cm,mlen1,mlen2); SetLb(cm,1,lb1); SetLb(cm,2,lb2); //SetUb(cm,1,ub1); // Should not be necessary - try it for test purposes //SetUb(cm,2,ub2); // Should not be necessary - try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &cm[lb1][lb2], mlen1*mlen2, MPI_CXSC_COMPLEX, MC); return err; } // ============================================================================= // MPI-Send/Recv for imatrix: // ============================================================================= int MPI_Send(imatrix& im, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(im,1); int lb2=Lb(im,2); int ub1=Ub(im,1); int ub2=Ub(im,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&im[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_INTERVAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(imatrix& im, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(im,1); int lb2=Lb(im,2); int ub1=Ub(im,1); int ub2=Ub(im,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&im[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_INTERVAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(imatrix& im, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int mlen1, mlen2, lb1, ub1, lb2, ub2; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb2, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub2, 1, MPI_INT, MC); mlen1=ub1-lb1+1; mlen2=ub2-lb2+1; Resize(im,mlen1,mlen2); SetLb(im,1,lb1); SetLb(im,2,lb2); //SetUb(im,1,ub1); // Should not be necessary - try it for test purposes //SetUb(im,2,ub2); // Should not be necessary - try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &im[lb1][lb2], mlen1*mlen2, MPI_CXSC_INTERVAL, MC); return err; } // ============================================================================= // MPI-Send/Recv for cimatrix: // ============================================================================= int MPI_Send(cimatrix& cim, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(cim,1); int lb2=Lb(cim,2); int ub1=Ub(cim,1); int ub2=Ub(cim,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&cim[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_CINTERVAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(cimatrix& cim, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(cim,1); int lb2=Lb(cim,2); int ub1=Ub(cim,1); int ub2=Ub(cim,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&cim[lb1][lb2],(ub1-lb1+1)*(ub2-lb2+1),MPI_CXSC_CINTERVAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(cimatrix& cim, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int mlen1, mlen2, lb1, ub1, lb2, ub2; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb2, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub2, 1, MPI_INT, MC); mlen1=ub1-lb1+1; mlen2=ub2-lb2+1; Resize(cim,mlen1,mlen2); SetLb(cim,1,lb1); SetLb(cim,2,lb2); //SetUb(cim,1,ub1); // Should not be necessary - try it for test purposes //SetUb(cim,2,ub2); // Should not be necessary - try it for test purposes MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &cim[lb1][lb2], mlen1*mlen2, MPI_CXSC_CINTERVAL, MC); return err; } // ============================================================================= // // Multiple precision data types (Matrices) // // ============================================================================= // ============================================================================= // MPI-Send/Recv for l_rmatrix: // ============================================================================= int MPI_Send(l_rmatrix& l_rm, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(l_rm,1); int lb2=Lb(l_rm,2); int ub1=Ub(l_rm,1); int ub2=Ub(l_rm,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb1;i<=ub1;i++) for (int j=lb2;j<=ub2;j++) { int prec=StagPrec(l_rm[i][j]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_rm[i][j][1],prec,MPI_CXSC_REAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(l_rmatrix& l_rm, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(l_rm,1); int lb2=Lb(l_rm,2); int ub1=Ub(l_rm,1); int ub2=Ub(l_rm,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb1;i<=ub1;i++) for (int j=lb2;j<=ub2;j++) { int prec=StagPrec(l_rm[i][j]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_rm[i][j][1],prec,MPI_CXSC_REAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(l_rmatrix& l_rm, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int mlen1, mlen2, lb1, ub1, lb2, ub2; int stagprectmp; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb2, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub2, 1, MPI_INT, MC); mlen1=ub1-lb1+1; mlen2=ub2-lb2+1; Resize(l_rm,mlen1,mlen2); SetLb(l_rm,1,lb1); SetLb(l_rm,2,lb2); //SetUb(l_rm,1,ub1); // Should not be necessary - try it for test purposes //SetUb(l_rm,2,ub2); // Should not be necessary - try it for test purposes for (int i=lb1;i<=ub1;i++) for (int j=lb2;j<=ub2;j++) { int lrprec; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lrprec, 1, MPI_INT, MC); stagprectmp=stagprec; stagprec=lrprec; l_real lr_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lr_temp[1], lrprec, MPI_CXSC_REAL, MC); l_rm[i][j]=lr_temp; } return err; } // ============================================================================= // MPI-Send/Recv for l_imatrix: // ============================================================================= int MPI_Send(l_imatrix& l_im, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(l_im,1); int lb2=Lb(l_im,2); int ub1=Ub(l_im,1); int ub2=Ub(l_im,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb1;i<=ub1;i++) for (int j=lb2;j<=ub2;j++) { int prec=StagPrec(l_im[i][j]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_im[i][j][1],prec+1,MPI_CXSC_REAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(l_imatrix& l_im, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; int lb1=Lb(l_im,1); int lb2=Lb(l_im,2); int ub1=Ub(l_im,1); int ub2=Ub(l_im,2); if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; MPI_Pack(&lb1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub1,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&lb2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&ub2,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); for (int i=lb1;i<=ub1;i++) for (int j=lb2;j<=ub2;j++) { int prec=StagPrec(l_im[i][j]); MPI_Pack(&prec,1,MPI_INT,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); MPI_Pack(&l_im[i][j][1],prec+1,MPI_CXSC_REAL,sendbuffer, MPI_CXSC_BUFFERLEN,&pos,MC); } err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(l_imatrix& l_im, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; int mlen1, mlen2, lb1, ub1, lb2, ub2; int stagprectmp; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub1, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &lb2, 1, MPI_INT, MC); MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &ub2, 1, MPI_INT, MC); mlen1=ub1-lb1+1; mlen2=ub2-lb2+1; Resize(l_im,mlen1,mlen2); SetLb(l_im,1,lb1); SetLb(l_im,2,lb2); //SetUb(l_im,1,ub1); // Should not be necessary - try it for test purposes //SetUb(l_im,2,ub2); // Should not be necessary - try it for test purposes for (int i=lb1;i<=ub1;i++) for (int j=lb2;j<=ub2;j++) { int liprec; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &liprec, 1, MPI_INT, MC); stagprectmp=stagprec; stagprec=liprec; l_interval li_temp; // Create temporary variable with received precision stagprec=stagprectmp; MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, &li_temp[1], liprec+1, MPI_CXSC_REAL, MC); l_im[i][j]=li_temp; } return err; } // ============================================================================= // // Dotprecision data types // // ============================================================================= // ============================================================================= // MPI-Send/Recv for dotprecision: // ============================================================================= int MPI_Send(dotprecision& dotac, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(dotac.ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(dotprecision& dotac, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(dotac.ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(dotprecision& dotac, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; a_btyp* akkuP=*(dotac.ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku return err; } // ============================================================================= // MPI-Send/Recv for idotprecision: // ============================================================================= int MPI_Send(idotprecision& idotac, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(Inf(idotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(Sup(idotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(idotprecision& idotac, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(Inf(idotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(Sup(idotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(idotprecision& idotac, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; a_btyp* akkuP=*(Inf(idotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(Sup(idotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); return err; } // ============================================================================= // MPI-Send/Recv for cdotprecision: // ============================================================================= int MPI_Send(cdotprecision& cdotac, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(Re(cdotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(Im(cdotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(cdotprecision& cdotac, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(Re(cdotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(Im(cdotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(cdotprecision& cdotac, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; a_btyp* akkuP=*(Re(cdotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(Im(cdotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); return err; } // ============================================================================= // MPI-Send/Recv for cidotprecision: // ============================================================================= int MPI_Send(cidotprecision& cidotac, int i1, int i2, MPI_Comm MC) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(InfRe(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(InfIm(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); akkuP=*(SupRe(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); akkuP=*(SupIm(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Send(sendbuffer, pos, MPI_PACKED, i1, i2, MC); return err; } int MPI_Isend(cidotprecision& cidotac, int i1, int i2, MPI_Comm MC, MPI_Request* MR) { int pos=0; char sendbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; a_btyp* akkuP=*(InfRe(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(InfIm(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); akkuP=*(SupRe(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); akkuP=*(SupIm(cidotac).ptr()); // Points to the same address as akku MPI_Pack((void*)akkuP,BUFFERSIZE,MPI_BYTE,sendbuffer,MPI_CXSC_BUFFERLEN,&pos,MC); err=MPI_Isend(sendbuffer, pos, MPI_PACKED, i1, i2, MC, MR); return err; } int MPI_Recv(cidotprecision& cidotac, int i1, int i2, MPI_Comm MC, MPI_Status* MS) { int pos=0; char* recbuffer[MPI_CXSC_BUFFERLEN]; int err; if (!MPI_CXSC_TYPES_DEFINED) if (err=MPI_Define_CXSC_Types()!=MPI_SUCCESS) return err; if (err=MPI_Recv(recbuffer, MPI_CXSC_BUFFERLEN, MPI_PACKED, i1, i2, MC, MS)!= MPI_SUCCESS) return err; a_btyp* akkuP=*(InfRe(cidotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); // BUFFERSIZE is an internal C-XSC variable controlling the // length of a dotprecision akku akkuP=*(InfIm(cidotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); akkuP=*(SupRe(cidotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); akkuP=*(SupIm(cidotac).ptr()); // Points to the same address as akku MPI_Unpack(recbuffer, MPI_CXSC_BUFFERLEN, &pos, akkuP, BUFFERSIZE, MPI_BYTE, MC); return err; }