int receive(heur_prob *p)
{
int r_bufid, info, bytes, msgtag, parent;
PVM_FUNC(r_bufid, pvm_recv(-1, VRP_BROADCAST_DATA));
PVM_FUNC(info, pvm_bufinfo(r_bufid, &bytes, &msgtag, &parent));
PVM_FUNC(info, pvm_upkint(&(p->dist.wtype), 1, 1));
PVM_FUNC(info, pvm_upkint(&(p->vertnum), 1, 1));
PVM_FUNC(info, pvm_upkint(&(p->depot), 1, 1));
PVM_FUNC(info, pvm_upkint(&p->capacity, 1, 1));
p->demand = (int *) calloc (p->vertnum, sizeof(int));
PVM_FUNC(info, pvm_upkint(p->demand, p->vertnum, 1));
p->edgenum = p->vertnum*(p->vertnum-1)/2;
if (p->dist.wtype){ /* not EXPLICIT */
p->dist.coordx = (double *) calloc(p->vertnum, sizeof(double));
p->dist.coordy = (double *) calloc(p->vertnum, sizeof(double));
PVM_FUNC(info, pvm_upkdouble(p->dist.coordx, p->vertnum, 1));
PVM_FUNC(info, pvm_upkdouble(p->dist.coordy, p->vertnum, 1));
if ((p->dist.wtype == _EUC_3D) || (p->dist.wtype == _MAX_3D) ||
(p->dist.wtype == _MAN_3D)){
p->dist.coordz = (double *) calloc(p->vertnum, sizeof(double));
PVM_FUNC(info, pvm_upkdouble(p->dist.coordz, p->vertnum, 1));
}
}
else{ /* EXPLICIT */
p->dist.cost = (int *) malloc (p->edgenum*sizeof(int));
PVM_FUNC(info, pvm_upkint(p->dist.cost, (int)p->edgenum, 1));
}
PVM_FUNC(info, pvm_freebuf(r_bufid));
return(parent);
}
void
StopwatchPVMUnpack(Stopwatch_t *w)
{
pvm_upkdouble(&(w->elapsed), 1, 1);
pvm_upkdouble(&(w->user), 1, 1);
pvm_upkdouble(&(w->sys), 1, 1);
}
int receive_assign(tassign *assign) {
int bufid, tag, dummy, datasize, i, toint[ASSIGN_NINT];
double *tdbl, todbl[ASSIGN_NDBL];
float *tflt;
bufid = pvm_recv(-1,-1);
pvm_bufinfo(bufid,&dummy,&tag,&dummy);
if (tag == 2) return 0;
pvm_upkint(toint,ASSIGN_NINT,1);
pvm_upkdouble(todbl,ASSIGN_NDBL,1);
assign->id = (integer)toint[ASSIGN_ID];
assign->chans = (integer)toint[ASSIGN_CHANS];
assign->frames = (integer)toint[ASSIGN_FRAMES];
assign->epochs = (integer)toint[ASSIGN_EPOCHS];
assign->bias = (integer)toint[ASSIGN_BIAS];
assign->signs = (integer)toint[ASSIGN_SIGNS];
assign->extended = (integer)toint[ASSIGN_EXTENDED];
assign->extblocks = (integer)toint[ASSIGN_EXTBLOCKS];
assign->pdfsize = (integer)toint[ASSIGN_PDFSIZE];
assign->nsub = (integer)toint[ASSIGN_NSUB];
assign->verbose = (integer)toint[ASSIGN_VERBOSE];
assign->block = (integer)toint[ASSIGN_BLOCK];
assign->maxsteps = (integer)toint[ASSIGN_MAXSTEPS];
assign->lrate = (doublereal)todbl[ASSIGN_LRATE];
assign->annealstep = (doublereal)todbl[ASSIGN_ANNEALSTEP];
assign->annealdeg = (doublereal)todbl[ASSIGN_ANNEALDEG];
assign->nochange = (doublereal)todbl[ASSIGN_NOCHANGE];
assign->momentum = (doublereal)todbl[ASSIGN_MOMENTUM];
datasize = assign->chans * assign->frames * assign->epochs;
assign->data = (doublereal*)malloc(datasize*sizeof(doublereal));
if (sizeof(float) != sizeof(doublereal)) {
tflt = (float*)malloc(datasize*sizeof(float));
pvm_upkfloat(tflt,datasize,1);
for (i=0 ; i<datasize ; i++) assign->data[i] = (doublereal)tflt[i];
free(tflt);
}
else
pvm_upkfloat((float*)(assign->data),datasize,1);
datasize = assign->chans * assign->chans;
assign->weights = (doublereal*)malloc(datasize*sizeof(doublereal));
if (sizeof(double) != sizeof(doublereal)) {
tdbl = (double*)malloc(datasize*sizeof(double));
pvm_upkdouble(tdbl,datasize,1);
for (i=0 ; i<datasize ; i++) assign->weights[i] = (doublereal)tdbl[i];
free(tdbl);
}
else
pvm_upkdouble((double*)(assign->weights),datasize,1);
pvm_freebuf(bufid);
return 1;
}
void main()
{
/* enroll in pvm */
mytid = pvm_mytid();
master = pvm_parent();
/* receive data from master */
pvm_recv(master, DATA);
pvm_upkint(&nproc, 1, 1);
pvm_upkdouble(&lower, 1, 1);
pvm_upkdouble(&upper, 1, 1);
pvm_upkdouble(&delta_x, 1, 1);
pvm_upkint(&partitions, 1, 1);
pvm_upkint(tids, nproc, 1);
/* determine which slave I am (0..nproc-1) */
for(i=0; i<nproc; i++)
if(mytid==tids[i]) {
mynode = i;
break;
}
/* start timiming */
start = clock();
/* calculate approximation */
partitions_per_slave = partitions / nproc;
first = lower + mynode * ((upper-lower)/nproc);
last = first + partitions_per_slave * delta_x;
x = first + (delta_x/2.0);
while(x<last)
{
approx_result += f(x) * delta_x;
x += delta_x;
}
/* end timing */
elapse = (clock() - start) / clocks_per_sec;
avg_time = elapse / partitions;
/* send the results back to the master program */
pvm_initsend(PvmDataDefault);
pvm_pkdouble(&elapse, 1, 1);
pvm_pkdouble(&approx_result, 1, 1);
pvm_pkdouble(&avg_time, 1, 1);
pvm_send(master, RESULTS);
/* exit pvm */
pvm_exit();
}
/**
* Description not yet available.
* \param
*/
void adpvm_unpack(const dvar_vector& _v)
{
dvar_vector& v = (dvar_vector&) _v;
int imin;
int imax;
pvm_upkint(&imin,1,1);
pvm_upkint(&imax,1,1);
if (allocated(v))
{
if (v.indexmin()!=imin)
{
cerr << "Error in min index in "
"void adpvm_unpack(const dvar_vector& v)" << endl;
ad_exit(1);
}
if (v.indexmax()!=imax)
{
cerr << "Error in max index in"
" void adpvm_unpack(const dvar_vector& v)" << endl;
ad_exit(1);
}
}
else
{
v.allocate(imin,imax);
}
pvm_upkdouble(&(value(v(imin))),imax-imin+1,1);
save_identifier_string("B");
v.save_dvar_vector_position();
save_identifier_string("D");
gradient_structure::GRAD_STACK1->
set_gradient_stack(adpvm_pack_vector_derivatives);
}
double BBSDirect::upkdouble() {
double x;
// printf("upkdouble from %d\n", pvm_getrbuf());
if( pvm_upkdouble(&x, 1, 1)) { perror("upkdouble"); }
// printf("upkdouble returning %g\n", x);
return x;
}
/**
* Description not yet available.
* \param
*/
void pvm_unpack(const dvar_vector& _v)
{
dvar_vector& v = (dvar_vector&) _v;
int imin;
int imax;
pvm_upkint(&imin,1,1);
pvm_upkint(&imax,1,1);
if (allocated(v))
{
if (v.indexmin()!=imin)
{
cerr << "Error in min index in "
"void pvm_unpack(const dvar_vector& v)" << endl;
ad_exit(1);
}
if (v.indexmax()!=imax)
{
cerr << "Error in max index in"
" void pvm_unpack(const dvar_vector& v)" << endl;
ad_exit(1);
}
}
else
{
v.allocate(imin,imax);
}
pvm_upkdouble(&(value(v(imin))),imax-imin+1,1);
}
int receive_dbl_array(double *array, int size)
{
int info;
PVM_FUNC(info, pvm_upkdouble(array, size, 1));
return(info);
}
/**
* Description not yet available.
* \param
*/
void adpvm_unpack_number_derivative(void)
{
verify_identifier_string("S");
double dv;
pvm_upkdouble(&dv,1,1);;
prevariable_position dvpos=restore_prevariable_position();
verify_identifier_string("R");
save_double_derivative(dv,dvpos);
}
/**
* Description not yet available.
* \param
*/
void adpvm_unpack(const prevariable& _v)
{
dvariable& v = (dvariable&) _v;
save_identifier_string("C");
v.save_prevariable_position();
save_identifier_string("D");
pvm_upkdouble((double*)(&(value(v))),1,1);
gradient_structure::GRAD_STACK1->
set_gradient_stack(adpvm_pack_number_derivative);
}
int main(int argc, char *argv[]){
int mytid, tids[MAXNODES];
int numt, n, nproc, msgtype;
double val, work, result;
double xs[10000];
double ys[10000][10000];
for(int i=0; i<10000; i++){
xs[i] = rand();
for(int j=0; i<10000; j++){
ys[i][j] = rand();
}
}
mytid = pvm_mytid();
nproc=4;
numt = pvm_spawn(CLIENTNAME, NULL, PvmTaskDefault, NULL, nproc, tids);
if (numt != nproc){
fprintf(stderr, "numt = %d, nproc = %d\n", numt, nproc);
fprintf(stderr, "error: pvm_spawn()\n");
pvm_exit();
exit(1);
}
msgtype=11;
for(n=0; n<nproc; n++){
pvm_initsend(PvmDataDefault);
pvm_pkint(&n, 1, 1);
pvm_pkdouble(&xs, 10000, 1);
pvm_pkdouble(&ys, 10000, 1);
pvm_send(tids[n], msgtype);
}
msgtype=22; result=0.0;
for(n=0; n<nproc; n++){
pvm_recv(-1, msgtype);
pvm_upkdouble(&work, 1, 1);
result += work;
}
printf("Result = %25.15lf\n", result);
return 0;
}
void BBSDirect::upkvec(int n, double* x) {
// printf("upkvec from %d\n", pvm_getrbuf());
if( pvm_upkdouble(x, n, 1)) { perror("upkvec"); }
}
int receive_result(tresult *result) {
int *tint, bufid, datasize, bias, signs, toint[RESULT_NINT];
int i, buflen, tag, tid;
double *tdbl, todbl[RESULT_NDBL];
bufid = pvm_recv(-1,-1);
pvm_upkint(toint,RESULT_NINT,1);
pvm_upkdouble(todbl,RESULT_NDBL,1);
result->id = (integer)toint[RESULT_ID];
result->chans = (integer)toint[RESULT_CHANS];
bias = (integer)toint[RESULT_BIAS];
signs = (integer)toint[RESULT_SIGNS];
result->lrate = (doublereal)todbl[RESULT_LRATE];
datasize = result->chans * result->chans;
result->weights = (doublereal*)malloc(datasize*sizeof(doublereal));
if (sizeof(double) != sizeof(doublereal)) {
tdbl = (double*)malloc(datasize*sizeof(double));
pvm_upkdouble(tdbl,datasize,1);
for (i=0 ; i<datasize ; i++) result->weights[i] = (doublereal)tdbl[i];
free(tdbl);
}
else
pvm_upkdouble((double*)(result->weights),datasize,1);
if (bias) {
datasize = result->chans;
result->bias = (doublereal*)malloc(datasize*sizeof(doublereal));
if (sizeof(double) != sizeof(doublereal)) {
tdbl = (double*)malloc(datasize*sizeof(double));
pvm_upkdouble(tdbl,datasize,1);
for (i=0 ; i<datasize ; i++) result->bias[i] = (doublereal)tdbl[i];
free(tdbl);
}
else
pvm_upkdouble((double*)(result->bias),datasize,1);
}
else
result->bias = NULL;
if (signs) {
datasize = result->chans;
result->signs = (integer*)malloc(datasize*sizeof(integer));
if (sizeof(int) != sizeof(integer)) {
tint = (int*)malloc(datasize*sizeof(int));
pvm_upkint(tint,datasize,1);
for (i=0 ; i<datasize ; i++) result->signs[i] = (integer)tint[i];
free(tint);
}
else
pvm_upkint((int*)(result->signs),datasize,1);
}
else
result->signs = NULL;
pvm_bufinfo(bufid,&buflen,&tag,&tid);
pvm_freebuf(bufid);
return tid;
}
void BBSClient::upkvec(int n, double* x) {
if( pvm_upkdouble(x, n, 1)) { perror("upkvec"); }
}
double UnpackNextDouble () {
double i;
assert (! pvm_upkdouble (&i, 1, 1));
return (i);
}
int main(int argc, char **argv)
{
int myTID;
int tids[NPROC] = {[0 ... NPROC-1] = 0};
int res;
myTID = pvm_mytid();
printf("Master: TID is %d\n", myTID);
double a;
double b;
int num_points;
a = atof(argv[1]);
b = atof(argv[2]);
num_points = atoi(argv[3]);
double begins[NPROC];
double ends[NPROC];
double basic_range = (b-a)/NPROC;
//double extra_range = fmod((b-a),NPROC);
for (int procindex = 0; procindex < NPROC; procindex++) {
begins[procindex] = procindex * basic_range;
ends[procindex] = begins[procindex] + basic_range;
printf("begins[%d]= %f ends[%d]= %f\n", procindex,begins[procindex], procindex,ends[procindex]);
}
printf ("basic_range = %f\n", basic_range);
res = pvm_spawn("slave", NULL, PvmTaskDefault, "", NPROC, tids);
printf("res %d\n", res);
if (res<1) {
printf("Master: pvm_spawn error\n");
pvm_exit();
exit(1);
}
//for (int procindex = 0; procindex < NPROC; procindex++) printf("tids[%d] = %d\n", procindex, tids[procindex]);
for (int procindex = 0; procindex < NPROC; procindex++) {
pvm_initsend(PvmDataDefault);
pvm_pkdouble(&begins[procindex], 1, 1);
pvm_pkdouble(&ends[procindex], 1, 1);
pvm_pkint(&num_points, 1, 1);
pvm_send(tids[procindex], 1);
}
double result=0;
for (int procindex = 0; procindex < NPROC; procindex++) {
double r=0;
pvm_recv(-1, -1);
pvm_upkdouble(&r, 1, 1);
printf("Master has received r=%f\n", r);
result += r;
}
printf("Result %f\n", result);
pvm_exit();
return 0;
}
int
main(void)
{
struct p7trace_s *tr; /* traceback of an alignment */
int master_tid; /* PVM TID of our master */
char *hmmfile; /* file to read HMM(s) from */
HMMFILE *hmmfp; /* opened hmmfile for reading */
struct plan7_s *hmm;
char *seq;
char *dsq;
int len;
int nhmm; /* number of HMM to work on */
float sc;
int my_idx = -1; /* my index, 0..nslaves-1 */
float globT; /* T parameter: keep only hits > globT bits */
double globE; /* E parameter: keep hits < globE E-value */
double pvalue; /* Z*pvalue = Evalue */
int Z; /* nseq to base E value calculation on */
int send_trace; /* TRUE if score is significant */
int do_xnu; /* TRUE to do XNU filter on seq */
int do_forward; /* TRUE to use Forward() scores not Viterbi */
int do_null2; /* TRUE to correct scores w/ ad hoc null2 */
int alphatype; /* alphabet type, hmmAMINO or hmmNUCLEIC */
int code; /* return code after initialization */
/* Register leave_pvm() cleanup function so any exit() call
* first calls pvm_exit().
*/
if (atexit(leave_pvm) != 0) { pvm_exit(); Die("slave couldn't register leave_pvm()"); }
/*****************************************************************
* initialization.
* Master broadcasts to us:
* 1) len of HMM file name (int)
* 2) name of HMM file (string)
* 3) length of sequence string (int)
* 4) sequence (string)
* 5) globT threshold
* 6) globE threshold
* 7) Z
* 8) do_xnu flag
* 9) do_forward flag
* 10) do_null2 flag
* 11) alphabet type
* We receive the broadcast and open the files.
******************************************************************/
master_tid = pvm_parent(); /* who's our master? */
pvm_recv(master_tid, HMMPVM_INIT);
pvm_upkint(&len, 1, 1);
hmmfile = MallocOrDie(sizeof(char *) * (len+1));
pvm_upkstr(hmmfile);
pvm_upkint(&len, 1, 1);
seq = MallocOrDie(sizeof(char *) * (len+1));
pvm_upkstr(seq);
pvm_upkfloat(&globT, 1, 1);
pvm_upkdouble(&globE, 1, 1);
pvm_upkint(&Z, 1, 1);
pvm_upkint(&do_xnu, 1, 1);
pvm_upkint(&do_forward, 1, 1);
pvm_upkint(&do_null2, 1, 1);
pvm_upkint(&alphatype, 1, 1);
SetAlphabet(alphatype);
/* Open HMM file (maybe in HMMERDB) */
code = HMMPVM_OK;
if ((hmmfp = HMMFileOpen(hmmfile, "HMMERDB")) == NULL)
code = HMMPVM_NO_HMMFILE;
else if (hmmfp->gsi == NULL)
code = HMMPVM_NO_INDEX;
/* report our status.
*/
pvm_initsend(PvmDataDefault);
pvm_pkint(&code, 1, 1);
pvm_send(master_tid, HMMPVM_RESULTS);
dsq = DigitizeSequence(seq, len);
if (do_xnu) XNU(dsq, len);
/*****************************************************************
* Main loop.
* Receive an integer 0..nhmm-1 for which HMM to search against.
* If we receive a -1, we shut down.
*****************************************************************/
for (;;)
{
pvm_recv(master_tid, HMMPVM_WORK);
pvm_upkint(&nhmm, 1, 1);
if (my_idx < 0) my_idx = nhmm; /* first time thru, remember what index we are. */
if (nhmm == -1) break; /* shutdown signal */
/* move to our assigned HMM in the HMM file, and read it
*/
HMMFilePositionByIndex(hmmfp, nhmm);
if (! HMMFileRead(hmmfp, &hmm)) Die("unexpected end of HMM file");
if (hmm == NULL) Die("unexpected failure to parse HMM file");
P7Logoddsify(hmm, TRUE);
/* Score sequence, do alignment (Viterbi), recover trace
*/
if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT)
{
SQD_DPRINTF1(("P7Viterbi(): Estimated size %d Mb\n", P7ViterbiSize(len, hmm->M)));
sc = P7Viterbi(dsq, len, hmm, &tr);
}
else
{
SQD_DPRINTF1(("P7SmallViterbi() called; %d Mb > %d\n", P7ViterbiSize(len, hmm->M), RAMLIMIT));
sc = P7SmallViterbi(dsq, len, hmm, &tr);
}
if (do_forward) sc = P7Forward(dsq, len, hmm, NULL);
if (do_null2) sc -= TraceScoreCorrection(hmm, tr, dsq);
pvalue = PValue(hmm, sc);
send_trace = (sc > globT && pvalue * (float) Z < globE) ? 1 : 0;
/* return output
*/
pvm_initsend(PvmDataDefault);
pvm_pkint(&my_idx, 1, 1); /* tell master who we are */
pvm_pkstr(hmm->name); /* double check that we did the right thing */
pvm_pkfloat(&sc, 1, 1);
pvm_pkdouble(&pvalue, 1, 1);
pvm_pkint(&send_trace, 1, 1); /* flag for whether a trace structure is coming */
if (send_trace) PVMPackTrace(tr);
pvm_send(master_tid, HMMPVM_RESULTS);
/* cleanup
*/
FreePlan7(hmm);
P7FreeTrace(tr);
}
/***********************************************
* Cleanup, return.
***********************************************/
HMMFileClose(hmmfp);
free(seq);
free(dsq);
free(hmmfile);
return 0;
}
/**
* Description not yet available.
* \param
*/
void adpvm_unpack(const double& _v)
{
double& v = (double&) _v;
pvm_upkdouble(&v,1,1);
}
void
RecvTime(ArgStruct *p, double *t)
{
pvm_recv(-1, -1);
pvm_upkdouble( t, 1, 1 );
}
/**
* Description not yet available.
* \param
*/
void pvm_unpack(const prevariable& _v)
{
dvariable& v = (dvariable&) _v;
pvm_upkdouble((double*)(&(value(v))),1,1);
}
double BBSClient::upkdouble() {
double x;
if( pvm_upkdouble(&x, 1, 1)) { perror("upkdouble"); }
return x;
}
