thanks, 

In this way, in myClass, I replace " double* myDouble" with " serializable_double myDouble". 

Can the " myDouble " be accessed as the original " double* " ? 

I need to assign some values to myDouble at first and then use boost MPI to 

transfer it to another process. 

For example,

if I use double*

double myVar =2.1 ;

double* myDouble =  &myVar ;

if I use  serializable_double , I need to do it in this way :

double myVar = 2.1 ;

serializable_double  myDouble =  &myVar ;

If I am wrong, please correct me. 

The following is the data structure that I want to transfer from one process to another process : 

-------------------------------------------------------------------------------

typedef struct {

    int rank;

    double constr_violation;

    double *xreal;

    int **gene;

    double *xbin;

    double *obj;

    double *constr;

    double crowd_dist;

   

}

individual;

typedef struct {

    individual *ind;

}

population;

-----------------------------------------------------------------------------------

I need to trasfer population from process 1 to process 2 such that the data members in 

population->ind can be operated in process 2.

Then, the process 2 returns the population->ind  with new results  to process 1. 

Becasue the population and individual data structure are also used by other programs 

in the same project, I do not want to change double8 to serializable_double inside 

them.

May I use assignment to do it ?

for example, 

myClass

{

    int rank;

    double constr_violation;

    serializable_double   xreal;

    serializable_int *gene; 

    serializable_double xbin;

    serializable_double obj;

    serializable_double constr;

    double crowd_dist;

} myObject;

myObject.xreal = (population->ind)->xreal;

Any help is appreciated. 

thanks

Jack 

Aug. 29 2010

Jack Bryan wrote:
> Thanks
>
>
> Is the m_sd a pointer that points to a double variable ?

 

>
>
> How to refer to the values pointed by m_sd ?

 

 

 

 

> For example, I transfer myClass from process 1 to process 2 :
>
>
> In process 1, I declear
>
>
> myClass
> {
> serializable_double m_sd;
>
>
> serializable_int m_sint;
>
>
> template<class Archive>
> void serialize(Archive &ar, const unsigned int version){
> ar & m_sd & m_sint;;
> }
> } myObject;
>

so far so good.

 

> In process 1 , I use
>
>
> world.isend(destRank, downStreamTaskTag, myObject);
>
>
> In process 2, I use
>
>
> world.recv(sourceRank, downStreamTaskTag, myObjectRecv);
>
>
> How to refer to the values pointed by m_sd in myClass ?

 

>
>
> May I use it in this way ?
>
>
> *(myObjectRecv.m_sd) ;

 

> If myObjectRecv.m_sd  is an address of a primitive variable,
> the address should be in process 1's memory space.
>
>
> How does the process 2 can modify the value of the variable
> pointed by a pointer with address in process 1's memory space ?

 

the de-serialization.

>
> I can use the similar way to do it for pointer's pointer ?
> such as double** ?

 

> Any help is appreciated ?

it is?