--- /dev/null
+
+/* copyright (c) 1996, 1997, 1998, 1999 William R. Pearson and the
+ U. of Virginia */
+
+/* $Name: fa_34_26_5 $ - $Id: p2_workcomp.c,v 1.49 2007/01/02 17:24:36 wrp Exp $ */
+
+/* This version is modifed to read all files, query and database,
+ through the manager process. Workers will now receive their
+ database from the manager, rather than reading it themselves. This
+ cuts down considerably on NFS traffic, simplifies searches of
+ multiple files, and allows use of clusters of slave nodes that do
+ not have NFS access */
+
+/* September, 1994 - this version has been modified to do two kinds of
+ searches, a general library search, or list of library sequences search.
+ The latter would be used to generate optimized scores for fasta and
+ to produce alignments */
+
+/* modified July, 2002, to provide query shuffle */
+
+/* modified October, 2005, to support struct a_res_str a_res -
+ coordinates of alignment in aa0[], aa1[]. Future modifications
+ will cause do_walign to be run only once - subsequent calls for
+ seqc[0,1] can be filled using a_res, by adding a_res to the
+ struct sqs2 array.
+
+ 19-March-2006 - modifications to call do_walign() only once, and
+ use the resulting a_res structure for subsequent calls to calc_id,
+ calcons, calcons_a, have been implemented. Also, the -V option is
+ now valid with the parallel programs.
+
+ 31-May-2006 - some functions (e.g. dropfs and dropff do not store
+ complete information in a_res - thus they cannot use this shortcut
+ (yet).
+
+*/
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef PVM_SRC
+#include "pvm3.h"
+#endif
+
+#ifdef MPI_SRC
+#include "mpi.h"
+#endif
+
+/*
+#define PvmDataDefault 0
+#define PvmTaskDefault 0
+*/
+#include "msg.h"
+#include "defs.h"
+#include "param.h"
+#include "w_mw.h"
+#include "structs.h"
+
+#ifdef MPI_SRC
+#define XTERNAL
+#endif
+#include "upam.h"
+#include "uascii.h"
+
+#ifdef PVM_SRC
+int worker, mytid;
+int nnodes, pinums[MAXNOD];
+#endif
+
+#include "drop_func.h"
+
+extern void alloc_pam (int d1, int d2, struct pstruct *ppst); /* allocate ppst->pam12,pam12x */
+extern int **alloc_pam2p (int len, int nsq);
+extern void w_init ();
+extern void irand(int);
+extern void revcomp(unsigned char *, int, int *);
+
+
+
+extern void initseq(char **seqc0, char **seqc0a, char **seqc1, char **seqca, int seqsiz);
+extern void freeseq(char **seqc0, char **seqc0a, char **seqc1, char **seqca);
+
+void send_bestr(int, int, struct comstr *, int, int);
+void send_bestr2(int, struct comstr2 *, int);
+void send_code(int, char *, int);
+
+extern void get_param (struct pstruct *ppst, char *pstring2, char *pstring3);
+extern void update_param(struct qmng_str *qm_msg, struct mngmsg *m_msg,
+ struct pstruct *ppst);
+extern int shuffle(unsigned char *, unsigned char *, int);
+extern int wshuffle(unsigned char *, unsigned char *, int, int, int *);
+
+extern char err_str[];
+
+/* local function declarations */
+void free_ares(struct sqs2 *, int itt, int *, int walign_cnt, int worker);
+
+
+
+void w_abort (p, p1)
+char *p, *p1;
+{
+ fprintf (stderr, " %s %s\n", p, p1);
+#ifdef PVM_SRC
+ pvm_exit();
+ exit (1);
+#endif
+#ifdef MPI_SRC
+ MPI_Abort(MPI_COMM_WORLD,1);
+#endif
+}
+
+#ifdef PVM_SRC
+main ()
+#endif
+#ifdef MPI_SRC
+void
+workcomp(int worker)
+#endif
+{
+ unsigned char *aa0[6], *aa1s, *aa0s; /* Query and library sequences */
+ struct mngmsg m_msg; /* start message from manager to worker 1 */
+ struct qmng_str qm_msg; /* updated for each query */
+ int last_msg_b[10]; /* last set of numbers */
+ struct sqs2 *seqpt; /* sequence pointers for chunk */
+ int seqbuf_n,seqbuf_s; /* number of sequences, length of sequences */
+ int max_sql; /* maximum number of sequences/node */
+ int *n1_arr; /* array of sequence lengths in buffer */
+ int *m_seqnm_arr; /* array of sequence numbers in buffer */
+ int *aa1i_arr; /* array of offsets into the buffer */
+ unsigned char *seq_buf; /* space for sequence data */
+ int ntx;
+ int nsq; /* effective alphabet size */
+ long curtype = ONETYPE; /* current send message type */
+ int ieven=0; /* flag for window shuffle */
+ int cur_n0;
+ int n1, n1over; /* length of query, library sequences */
+ struct comstr bestr[BFR+1]; /* best structures */
+ struct comstr2 bestr2[BFR2+1]; /* best structures */
+ struct a_struct aln, *aln_dp;
+ int qres_bufsize; /* results buffer size */
+ int bestcnt = 0; /* how many best structures are full */
+ char gstring2[MAX_STR]; /* parameter string for manager */
+ char gstring3[MAX_STR]; /* parameter string for manager */
+ struct pstruct pst; /* parameter structure */
+ struct rstruct rst, qrst, rrst; /* results structure */
+ void *f_str[6], *qf_str;
+ int sw_score;
+ int lcnt, count, seqnm; /* counters */
+ int *walign_done[2], walign_cnt[2]; /* index of current valid a_res in seqpt */
+ int have_walign;
+ int *tres; /* allocated storage for seqpt[].a_res[].res */
+ int lend; /*global library sequence number information */
+ int lsn; /* library sequence number */
+ struct stage2_str *liblist=NULL; /* list of sequences to search */
+ int i, j; /* my turn to send sequence descriptions */
+ char libstr[21];
+ char errstr[128];
+ int itt=0;
+ int bufid;
+ char *seqc0, *seqc0a, *seqc1, *seqca;
+ char *seqc, *seqc_buff;
+ int seqc_buff_cnt, seqc_buff_len, seqc_flag;
+ int maxc, lc, nc, nident, ngap, aln_code_n;
+ float percent, gpercent;
+ int old_shuffle=0; /* did a qshuffle last time */
+ int hosttid=0;
+ char worker_str[5];
+
+#ifdef MPI_SRC
+ MPI_Status mpi_status;
+#endif
+
+#ifdef PVM_SRC
+ mytid = pvm_mytid();
+ hosttid = pvm_parent();
+#endif
+
+ w_init(); /* sets up default sascii, hsq, sq */
+
+ /* Allocate space for the query sequence */
+ if ((aa0[0] = (unsigned char *) malloc ((MAXTST+2+SEQ_PAD)*sizeof (char))) == NULL) {
+ w_abort ("Unable to allocate sequence array[0] - exiting!","");
+ }
+ *aa0[0]='\0';
+ aa0[0]++;
+
+ /* initial messages set up various parameter structures:
+
+ STARTTYPE0: &nnodes
+ pinums
+ &m_msg
+
+ STARTTYPE1 &pst
+
+ STARTTYPE2 pam12
+ STARTTYPE3 pam12x
+ */
+
+#ifdef PVM_SRC
+#ifdef ROUTE_DIRECT
+ pvm_setopt(PvmRoute,PvmRouteDirect);
+#endif
+ /* get number of nodes, pinums */
+ bufid = pvm_recv(hosttid,STARTTYPE0);
+ pvm_upkint(&nnodes,1,1);
+ pvm_upkint(pinums,nnodes,1);
+ pvm_upkbyte((char *)&m_msg,(int)sizeof(m_msg),1);
+ worker = tidtonode(mytid);
+ pvm_freebuf(bufid);
+#endif
+
+ sprintf(worker_str,"@%d",worker);
+
+#ifdef MPI_SRC
+ MPI_Recv(&m_msg,sizeof(m_msg),MPI_BYTE,hosttid,STARTTYPE0,MPI_COMM_WORLD,
+ &mpi_status);
+#endif
+
+ /* the aln structure needs some information from m_msg0.aln */
+ memcpy(&aln,&m_msg.aln,sizeof(struct a_struct));
+
+ /*
+ fprintf(stderr,"d1: %d d2: %d\n",m_msg.pamd1,m_msg.pamd2);
+ */
+
+ /* get pst params */
+#ifdef PVM_SRC
+ bufid = pvm_recv(hosttid,STARTTYPE1);
+ pvm_upkbyte((char *)&pst,(int)sizeof(pst),1);
+ /* 31t nsq = pst.nsq; */
+ pvm_upkbyte((char *)pascii,(int)sizeof(aascii),1);
+ pvm_freebuf(bufid);
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(&pst,(int)sizeof(pst),MPI_BYTE,hosttid,STARTTYPE1,MPI_COMM_WORLD,
+ &mpi_status);
+
+ MPI_Recv(pascii,(int)sizeof(aascii)/sizeof(int),MPI_INT,hosttid,STARTTYPE1,MPI_COMM_WORLD,
+ &mpi_status);
+#endif
+
+ if (pst.ext_sq_set) { nsq = pst.nsqx;}
+ else { nsq = pst.nsq;}
+
+ aa0[5] = aa0[4] = aa0[3] = aa0[2] = aa0[1] = aa0[0];
+ if (m_msg.qframe == 2) {
+ if ((aa0[1]=(unsigned char *)malloc((MAXTST+2)*sizeof (char)))==NULL)
+ w_abort ("Unable to allocate sequence[1] array - exiting!","");
+ *aa0[1]='\0';
+ aa0[1]++;
+ }
+
+ if ((aa1s=(unsigned char *)malloc((m_msg.max_tot+1)*sizeof (char)))==NULL)
+ w_abort ("Unable to allocate shuffled library sequence", "");
+ *aa1s=0;
+ aa1s++;
+
+ irand(0); /* necessary for shuffled sequences */
+
+ /* this function allocates pam12, pam12x
+ assigns pst.pam[0][0]=pam12, pst.pam[1][0] = pam12x
+ and sets up the correct pst.pam[0][0][0] pointers */
+
+ alloc_pam(m_msg.pamd1,m_msg.pamd2,&pst);
+
+#ifdef PVM_SRC
+ bufid = pvm_recv(hosttid,STARTTYPE2);
+ pvm_upkint(pam12,m_msg.pamd1*m_msg.pamd2,1);
+ pvm_freebuf(bufid);
+
+ bufid = pvm_recv(hosttid,STARTTYPE3);
+ pvm_upkint(pam12x,m_msg.pamd1*m_msg.pamd2,1);
+ pvm_freebuf(bufid);
+#endif
+
+#ifdef DEBUG
+ if (worker==FIRSTNODE) {
+ fprintf(stderr,"ext?: %d\tnsq: %d\tnsqx: %d\n",pst.ext_sq_set,pst.nsq, pst.nsqx);
+ for (i=1; i<5; i++) {
+ for (j=1; j <= i; j++) fprintf(stderr," %c,%c:%2d",pst.sq[i],pst.sq[j],pst.pam2[0][i][j]);
+ fprintf(stderr,"\n");
+ }
+ for (i=pst.nsq+1; i<pst.nsq+5; i++) {
+ for (j=pst.nsq+1; j <= i; j++) fprintf(stderr," %c,%c:%2d",pst.sqx[i],pst.sqx[j],pst.pam2[0][i][j]);
+ fprintf(stderr,"\n");
+ }
+
+ for (i=1; i<5; i++) {
+ for (j=1; j <= i; j++) fprintf(stderr," %c,%c:%2d",pst.sqx[i],pst.sqx[j],pst.pam2[1][i][j]);
+ fprintf(stderr,"\n");
+ }
+ for (i=pst.nsq+1; i<pst.nsq+5; i++) {
+ for (j=pst.nsq+1; j <= i; j++) fprintf(stderr," %c,%c:%2d",pst.sqx[i],pst.sqx[j],pst.pam2[1][i][j]);
+ fprintf(stderr,"\n");
+ }
+ }
+#endif
+
+#ifdef MPI_SRC
+ MPI_Recv(pam12,m_msg.pamd1*m_msg.pamd2,MPI_INT,hosttid,STARTTYPE2,
+ MPI_COMM_WORLD,&mpi_status);
+
+ MPI_Recv(pam12x,m_msg.pamd1*m_msg.pamd2,MPI_INT,hosttid,STARTTYPE3,
+ MPI_COMM_WORLD,&mpi_status);
+#endif
+
+/*
+ We have the PAM matrices - get the library sequences
+*/
+
+ /* Allocate space for the sequences */
+ max_sql = MAXSQL/2;
+
+ if ((seqpt=(struct sqs2 *)calloc(max_sql,sizeof(struct sqs2)))==NULL)
+ w_abort("cannot allocate seqpt(sqs2)","");
+
+ if ((n1_arr=(int *)calloc(m_msg.pbuf_siz+1,sizeof(int)))==NULL)
+ w_abort("cannot allocate n1_arr","");
+
+ if ((aa1i_arr=(int *)calloc(m_msg.pbuf_siz+1,sizeof(int)))==NULL)
+ w_abort("cannot allocate n1_arr","");
+
+ if ((m_seqnm_arr=(int *)calloc(m_msg.pbuf_siz+1,sizeof(int)))==NULL)
+ w_abort("cannot allocate m_seqnm_arr","");
+
+/*****************************************************************/
+/* This section gets all the database sequences from the manager */
+/*****************************************************************/
+
+ lcnt = 0;
+ while (1) {
+#ifdef PVM_SRC
+ /* get the number of sequences, sequence lengths */
+ bufid = pvm_recv(hosttid,STARTTYPE4);
+ pvm_upkint(&seqbuf_n,1,1); /* number of sequences */
+ pvm_upkint(&seqbuf_s,1,1); /* size of sequence buffer */
+ pvm_upkint(n1_arr,seqbuf_n,1); /* length of each sequence in buffer */
+ pvm_upkint(aa1i_arr,seqbuf_n,1); /* indexes for each sequence */
+ pvm_upkint(m_seqnm_arr,seqbuf_n,1); /* number of each library sequence */
+ pvm_freebuf(bufid);
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(&seqbuf_n,1,MPI_INT,hosttid,STARTTYPE4,MPI_COMM_WORLD,
+ &mpi_status);
+ MPI_Recv(&seqbuf_s,1,MPI_INT,hosttid,STARTTYPE4,MPI_COMM_WORLD,
+ &mpi_status);
+ MPI_Recv(n1_arr,seqbuf_n,MPI_INT,hosttid,STARTTYPE4,MPI_COMM_WORLD,
+ &mpi_status);
+ MPI_Recv(aa1i_arr,seqbuf_n,MPI_INT,hosttid,STARTTYPE4,MPI_COMM_WORLD,
+ &mpi_status);
+ MPI_Recv(m_seqnm_arr,seqbuf_n,MPI_INT,hosttid,STARTTYPE4,MPI_COMM_WORLD,
+ &mpi_status);
+#endif
+
+ if (seqbuf_n <= 0) break;
+#ifdef DEBUG
+ /*
+ fprintf(stderr,"[%d] seqbuf_n: %d seqbuf_s: %d\n",
+ worker,seqbuf_n,seqbuf_s);
+ fprintf(stderr,"[%d] lcnt: %d n1: %d seqnm %d\n",
+ worker,0,n1_arr[0],m_seqnm_arr[0]);
+ fprintf(stderr,"[%d] lcnt: %d n1: %d seqnm %d\n",
+ worker,1,n1_arr[1],m_seqnm_arr[1]);
+ */
+#endif
+
+ /* allocate space for sequences */
+ if ((seq_buf = (unsigned char *)calloc((size_t)seqbuf_s+1,sizeof(char)))
+ ==NULL) {
+ w_abort("cannot allocate tmp_seq","");
+ }
+ seq_buf++; /* leave a '\0' at the start */
+
+ /* get the sequence buffer */
+#ifdef PVM_SRC
+ bufid = pvm_recv(hosttid,STARTTYPE5);
+ pvm_upkbyte((char *)seq_buf,seqbuf_s,1);
+ pvm_freebuf(bufid);
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(seq_buf,seqbuf_s,MPI_BYTE,hosttid,STARTTYPE5,MPI_COMM_WORLD,
+ &mpi_status);
+#endif
+
+ /* now we have everything - update the pointers */
+ if (lcnt+seqbuf_n >= max_sql) {
+ max_sql += max(MAXSQL/2,seqbuf_n);
+ if ((seqpt=(struct sqs2 *)realloc(seqpt,max_sql*sizeof(struct sqs2)))
+ ==NULL)
+ w_abort("cannot allocate seqpt(sqs2)","");
+ }
+
+ /* convert from offsets to pointers into buffer */
+ /* ntx = 0; */
+ for (i=0; i<seqbuf_n; i++,lcnt++) {
+ seqpt[lcnt].n1 = n1_arr[i];
+ seqpt[lcnt].m_seqnm = m_seqnm_arr[i];
+ seqpt[lcnt].aa1 = &seq_buf[aa1i_arr[i]];
+ /* ntx += n1_arr[i]+1 + SEQ_PAD */
+
+#ifdef DEBUG
+ /* must have null's at both ends of sequence */
+ if (seqpt[lcnt].aa1[-1]!= '\0') {
+ fprintf(stderr,"Missing null at start: %d %d\n",
+ lcnt,seqpt[lcnt].aa1[-1]);
+ seqpt[lcnt].aa1[-1]='\0';
+ }
+ if (seqpt[lcnt].aa1[seqpt[lcnt].n1]!= '\0') {
+ fprintf(stderr,"Missing null at end: %d %d\n",
+ lcnt,seqpt[lcnt].aa1[seqpt[lcnt].n1]);
+ seqpt[lcnt].aa1[seqpt[lcnt].n1]='\0';
+ }
+#endif
+ }
+ }
+ /* all done - lcnt has the total number of library sequences */
+
+#ifdef DEBUG
+ if (lcnt > 0)
+ for (i=0; i<10; i++) {
+ for (j=0; j<10; j++) libstr[j]=pst.sq[seqpt[i].aa1[j]];
+ libstr[10]='\0';
+ fprintf(stderr,"[%d] n1: %d seqnm: %d aa1: %s\n",
+ worker,seqpt[i].n1,seqpt[i].m_seqnm,libstr);
+ }
+#endif
+
+ /* send back the number of descriptions received */
+
+#ifdef PVM_SRC
+ pvm_initsend(PvmDataRaw);
+ pvm_pkint(&lcnt,1,1);
+ pvm_send(hosttid,STARTTYPE0);
+#endif
+#ifdef MPI_SRC
+/* p4_dprintf(" have %d descriptions to send\n",lcnt); */
+ MPI_Send(&lcnt,1,MPI_INT,hosttid,STARTTYPE0,MPI_COMM_WORLD);
+#endif
+
+/*****************************************************************/
+/* Library reads are finished, get ready to do searches */
+/*****************************************************************/
+
+ /* get last set of numbers */
+#ifdef PVM_SRC
+ bufid = pvm_recv(hosttid,STARTTYPE0);
+ pvm_upkint(last_msg_b,2,1);
+ pvm_freebuf(bufid);
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(last_msg_b, 2, MPI_INT, hosttid, STARTTYPE0, MPI_COMM_WORLD,
+ &mpi_status);
+#endif
+ m_msg.nbr_seq = last_msg_b[0];
+ qres_bufsize = last_msg_b[1];
+
+#ifdef DEBUG
+#ifdef PVM_SRC
+ fprintf(stderr,"[%d] have nbr_seq %d qres_bufsize %d\n",worker,
+ m_msg.nbr_seq, qres_bufsize);
+#endif
+#ifdef MPI_SRC
+ /* p4_dprintf("[%d] have nbr_seq %d qres_bufsize %d\n",worker,
+ m_msg.nbr_seq, qres_bufsize);
+ */;
+#endif
+#endif
+ /* If self search, receive sequence numbering data */
+ if (m_msg.self) {
+#ifdef PVM_SRC
+ bufid = pvm_recv(hosttid,STARTTYPE1);
+ pvm_upkint(&lend,1,1);
+ pvm_freebuf(bufid);
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(&lend,1,MPI_INT,hosttid,STARTTYPE1,MPI_COMM_WORLD,&mpi_status);
+#endif
+ }
+
+ /* allocate space for a_res flag array */
+
+ if ((walign_done[0] = (int *)calloc(lcnt,sizeof(int)))==NULL) {
+ w_abort("cannot allocate walign_done");
+ }
+ walign_cnt[0]=0;
+
+ if ((walign_done[1] = (int *)calloc(lcnt,sizeof(int)))==NULL) {
+ w_abort("cannot allocate walign_done");
+ }
+ walign_cnt[1]=0;
+
+ /* was commented in for only FASTX/TFASTX, but do it always to
+ simplify */
+ aainit(pst.tr_type, pst.debug_lib);
+ pst.maxlen = m_msg.maxn;
+
+/*****************************************************************/
+/* Main search loop, which calles do_work() repeatedly */
+/*****************************************************************/
+
+ cur_n0 = 0;
+ while (1) {
+/*
+#ifdef DEBUG
+#ifdef PVM_SRC
+ fprintf(stderr," W: %d waiting MSEQTYPE\n",worker);
+#endif
+#ifdef MPI_SRC
+ p4_dprintf(" W: %d waiting MSEQTYPE\n",worker);
+#endif
+#endif
+*/
+
+/*****************************************************************/
+/* Wait for a query sequence from the manager */
+/*****************************************************************/
+
+#ifdef PVM_SRC
+ bufid = pvm_recv(hosttid,MSEQTYPE);
+ pvm_upkbyte((char *)&qm_msg,sizeof(qm_msg),1);
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(&qm_msg,sizeof(struct mngmsg),MPI_BYTE,hosttid,MSEQTYPE,
+ MPI_COMM_WORLD,&mpi_status);
+#endif
+#ifdef DEBUG
+ fprintf(stderr,"[%d] have MSEQTYPE n0: %d s_func: %d slist: %d qf: %d\n",
+ worker,qm_msg.n0,qm_msg.s_func,qm_msg.slist,qm_msg.qshuffle);
+#endif
+
+/*****************************************************************/
+/* New query sequence indicated by qm_msg.slist=0 */
+/*****************************************************************/
+
+ if (qm_msg.n0 > 0 && qm_msg.slist == 0) {
+
+ if (cur_n0 > 0) {
+
+/*****************************************************************/
+/* free everything associated with previous search */
+/*****************************************************************/
+
+ close_work (aa0[0], cur_n0, &pst, &f_str[0]);
+ free_ares(seqpt, 0, walign_done[0], walign_cnt[0], worker);
+ walign_cnt[0] = 0;
+ if (m_msg.ann_flg) free(m_msg.aa0a);
+
+
+ if (m_msg.qframe == 2) {
+ close_work(aa0[1], cur_n0, &pst, &f_str[1]);
+ free_ares(seqpt, 1, walign_done[1], walign_cnt[1], worker);
+ walign_cnt[1] = 0;
+ }
+ if (old_shuffle) {
+ close_work(aa0s,cur_n0, &pst, &qf_str);
+ aa0s--;
+ free(aa0s);
+ old_shuffle = 0;
+ }
+ if (pst.pam_pssm) {
+ free_pam2p(pst.pam2p[0]);
+ free_pam2p(pst.pam2p[1]);
+ }
+ }
+
+/*****************************************************************/
+/* Start allocating things for the next search */
+/*****************************************************************/
+
+ pst.pam_pssm = qm_msg.pam_pssm;
+ cur_n0 = qm_msg.n0;
+ if (m_msg.ann_flg) {
+ if ((m_msg.aa0a = calloc(qm_msg.n0+1,sizeof(char)))==NULL) {
+ w_abort(" cannot allocate aa0a");
+ }
+ }
+
+/*****************************************************************/
+/* Get the next query sequence */
+/*****************************************************************/
+
+#ifdef PVM_SRC
+ pvm_upkbyte((char *)aa0[0],qm_msg.n0+1+SEQ_PAD,1);
+ if (m_msg.ann_flg) {
+ pvm_upkbyte((char *)m_msg.aa0a,qm_msg.n0+1,1);
+ }
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(aa0[0],qm_msg.n0+1+SEQ_PAD,MPI_BYTE,hosttid,
+ MSEQTYPE1,MPI_COMM_WORLD, &mpi_status);
+ if (m_msg.ann_flg) {
+ MPI_Recv(m_msg.aa0a,qm_msg.n0+1,MPI_BYTE,hosttid,
+ MSEQTYPE2,MPI_COMM_WORLD, &mpi_status);
+ }
+#endif
+
+#ifdef DEBUG
+ /* must have null's at both ends of sequence */
+ if (aa0[0][-1]!= '\0') {
+ fprintf(stderr,"Missing null at start: %s %d\n",
+ qm_msg.libstr,aa0[0][-1]);
+ aa0[0][-1]='\0';
+ }
+ if (aa0[0][qm_msg.n0]!= '\0') {
+ fprintf(stderr,"Missing null at end: %s %d\n",
+ qm_msg.libstr,aa0[0][qm_msg.n0]);
+ aa0[qm_msg.n0]='\0';
+ }
+
+ /* This discovers most reasons for core dumps */
+ if (pst.debug_lib)
+ for (j=0; j<qm_msg.n0; j++)
+ if (aa0[0][j]>pst.nsq) {
+ fprintf(stderr,
+ "seq: %s residue[%d/%d] %d range (%d)\n",
+ qm_msg.libstr,j,qm_msg.n0,aa0[0][j],pst.nsq);
+ aa0[0][j]=0;
+ qm_msg.n0=j-1;
+ break;
+ }
+#endif
+ update_params(&qm_msg,&m_msg,&pst);
+ }
+
+/*****************************************************************/
+/* End of free()'s/ initialization for new sequence */
+/*****************************************************************/
+
+#ifdef PVM_SRC
+ pvm_freebuf(bufid);
+#endif
+
+ if (qm_msg.n0 == -1) {
+
+/*****************************************************************/
+/* All done with searches */
+/*****************************************************************/
+/* printf(" %d: got n0 == -1\n",worker); */
+ break;
+ }
+
+ /* p4_dprintf(" W:%d n0:%d slist:%d s_func:%d (%d)\n",worker,qm_msg.n0,qm_msg.slist,qm_msg.s_func,qres_bufsize); */
+
+/*****************************************************************/
+/* if qm_msg.slist > 0, search specific sequences, to be sent */
+/*****************************************************************/
+
+ if (qm_msg.slist > 0) { /* list search, not library search */
+ if (liblist != NULL) free(liblist);
+
+ /* get the list of sequences */
+ if ((liblist=(struct stage2_str *)
+ calloc(qm_msg.slist,sizeof(struct stage2_str)))==NULL) {
+ sprintf(errstr,"sequence list %d",qm_msg.slist);
+ w_abort (errstr, "");
+ }
+
+#ifdef PVM_SRC
+ bufid = pvm_recv(hosttid,LISTTYPE);
+ pvm_upkbyte((char *)liblist,qm_msg.slist*sizeof(struct stage2_str),1);
+ pvm_freebuf(bufid);
+#endif
+#ifdef MPI_SRC
+ MPI_Recv(liblist,qm_msg.slist*sizeof(struct stage2_str),MPI_BYTE,
+ hosttid,LISTTYPE,MPI_COMM_WORLD, &mpi_status);
+#endif
+ }
+
+/*****************************************************************/
+/* have list of sequences to be compared/aligned */
+/*****************************************************************/
+
+ /* Initial stuff */
+ if (qm_msg.slist == 0) {
+/*****************************************************************/
+/* New query - set up matrices and init_work() */
+/*****************************************************************/
+#ifdef DEBUG
+/*
+ fprintf(stderr,"n1: %d\t",qm_msg.n0);
+ for (i=0; i<10; i++) fprintf(stderr,"%c",nt[aa0[0][i]]);
+ fprintf(stderr,"\n");
+*/
+#endif
+ if (pst.pam_pssm) {
+ pst.pam2p[0] = alloc_pam2p(qm_msg.n0,nsq);
+ pst.pam2p[1] = alloc_pam2p(qm_msg.n0,nsq);
+ }
+
+ init_work (aa0[0], qm_msg.n0, &pst, &f_str[0]);
+ f_str[5]=f_str[4]=f_str[3]=f_str[2]=f_str[1]=f_str[0];
+
+ if (qm_msg.qshuffle) {
+ if ((aa0s=(unsigned char *)malloc((qm_msg.n0+2)*sizeof (char)))==NULL)
+ w_abort ("Unable to allocate aa0s array - exiting!","");
+ *aa0s='\0';
+ aa0s++;
+
+ memcpy(aa0s,aa0[0],qm_msg.n0+1);
+ qshuffle(aa0s,qm_msg.n0,qm_msg.nm0);
+#ifdef DEBUG
+ fprintf(stderr,"[%d] shuffle: %d\n",worker,qm_msg.n0);
+ fputs(" ",stderr);
+ for (i=0; i<5; i++) {fprintf(stderr,"%c",pst.sq[aa0s[i]]);}
+ fputc('\n',stderr);
+#endif
+
+ init_work (aa0s, qm_msg.n0, &pst, &qf_str);
+ old_shuffle=1;
+ }
+
+ if (m_msg.qframe == 2) {
+ memcpy(aa0[1],aa0[0],qm_msg.n0+1);
+ revcomp(aa0[1],qm_msg.n0,&pst.c_nt[0]);
+ init_work (aa0[1], qm_msg.n0, &pst, &f_str[1]);
+ }
+#ifdef DEBUG
+/*
+ fprintf(stderr,"[%d] init_work qf: %d nf: %d\n",worker,m_msg.qframe,m_msg.nframe);
+*/
+#endif
+ }
+
+/*****************************************************************/
+/* Finished with initialization, */
+/* start doing comparisons or alignments */
+/*****************************************************************/
+
+ bestcnt = 0;
+ if (qm_msg.slist == 0) { /* library search */
+
+/*****************************************************************/
+/* Start library search */
+/*****************************************************************/
+
+ for (count=0; count < lcnt; count++) {
+
+ for (itt=m_msg.revcomp; itt<=m_msg.nitt1; itt++) {
+
+ rst.score[0] = rst.score[1] = rst.score[2] = 0;
+ if (m_msg.self) {
+ lsn = lend + count;
+ if ((qm_msg.seqnm > lsn) && (((qm_msg.seqnm + lsn) % 2) != 0)) {
+ do_work (aa0[itt], qm_msg.n0,seqpt[count].aa1, seqpt[count].n1,
+ itt, &pst, f_str[itt], 0, &rst);
+ }
+ else if ((qm_msg.seqnm <= lsn) && (((qm_msg.seqnm+lsn)%2) == 0)) {
+ do_work (aa0[itt], qm_msg.n0, seqpt[count].aa1, seqpt[count].n1,
+ itt, &pst, f_str[itt], 0, &rst);
+ }
+ else continue;
+ }
+ else {
+ do_work (aa0[itt], qm_msg.n0, seqpt[count].aa1, seqpt[count].n1,
+ itt, &pst, f_str[itt], 0, &rst);
+ if (qm_msg.qshuffle) {
+ do_work (aa0s, qm_msg.n0, seqpt[count].aa1, seqpt[count].n1,
+ itt, &pst, qf_str, 1, &qrst);
+ }
+ }
+#ifdef DEBUG
+/*
+ if (count < 10 || (count % 200 == 199)) {
+ fprintf(stderr,"[node %d] itt:%d/%d (%d) %3d %3d %3d - %d/%d\n",
+ worker,itt,m_msg.nitt1,count,
+ rst.score[0],rst.score[1],rst.score[2],
+ seqpt[count].m_seqnm,seqpt[count].n1);
+ }
+*/
+#endif
+ sw_score = -1;
+
+ bestr[bestcnt].seqnm = count;
+ bestr[bestcnt].m_seqnm = seqpt[count].m_seqnm;
+ bestr[bestcnt].score[0] = rst.score[0];
+ bestr[bestcnt].score[1] = rst.score[1];
+ bestr[bestcnt].score[2] = rst.score[2];
+ bestr[bestcnt].escore = rst.escore;
+ bestr[bestcnt].segnum = rst.segnum;
+ bestr[bestcnt].seglen = rst.seglen;
+ bestr[bestcnt].frame = itt;
+ bestr[bestcnt].comp = rst.comp;
+ bestr[bestcnt].H = rst.H;
+
+ bestr[bestcnt].qr_score = qrst.score[pst.score_ix];
+ bestr[bestcnt].qr_escore = qrst.escore;
+
+ if (pst.zsflag >= 10) {
+ if (pst.zs_win > 0)
+ wshuffle(seqpt[count].aa1, aa1s,seqpt[count].n1,pst.zs_win,&ieven);
+ else
+ shuffle(seqpt[count].aa1, aa1s,seqpt[count].n1);
+
+ do_work(aa0[itt],qm_msg.n0,aa1s,seqpt[count].n1,itt, &pst,
+ f_str[itt], 0, &rst);
+ bestr[bestcnt].r_score = rst.score[pst.score_ix];
+ }
+
+ bestcnt++;
+ if (bestcnt >= qres_bufsize) {
+#ifdef DEBUG
+ fprintf(stderr," worker: %d sending %d results\n",worker,qres_bufsize);
+#endif
+ send_bestr(hosttid,curtype,bestr,qres_bufsize,bestcnt);
+ bestcnt = 0;
+ }
+ }
+ } /* END - for count loop */
+ send_bestr(hosttid, curtype, bestr,qres_bufsize, (bestcnt | FINISHED));
+ }
+
+/*****************************************************************/
+/* End of library search section */
+/*****************************************************************/
+
+/*****************************************************************/
+/* Do do_opt() from list s_func=DO_CALC_FLG */
+/*****************************************************************/
+
+ else if (qm_msg.s_func== DO_CALC_FLG) { /* qm_msg.slist > 0 */
+
+ bestcnt = 0;
+ for (count=0; count < qm_msg.slist; count++) {
+ rst.score[0] = rst.score[1] = rst.score[2] = 0;
+ itt = liblist[count].frame;
+ seqnm = bestr2[bestcnt].seqnm = liblist[count].seqnm;
+ bestr2[bestcnt].m_seqnm = seqpt[seqnm].m_seqnm;
+
+ do_opt (aa0[itt], qm_msg.n0, seqpt[seqnm].aa1,
+ seqpt[seqnm].n1, itt,
+ &pst, f_str[itt], &rst);
+
+ bestr2[bestcnt].score[0] = rst.score[0];
+ bestr2[bestcnt].score[1] = rst.score[1];
+ bestr2[bestcnt].score[2] = rst.score[2];
+ bestr2[bestcnt].escore = rst.escore;
+ bestr2[bestcnt].segnum = rst.segnum;
+ bestr2[bestcnt].seglen = rst.seglen;
+ bestr2[bestcnt].aln_code_n = 0;
+ bestcnt++;
+
+ if (bestcnt >= BFR2) {
+ send_bestr2(hosttid,bestr2,bestcnt);
+ bestcnt = 0;
+ }
+ } /* END - for count loop */
+
+ send_bestr2(hosttid,bestr2,(bestcnt|FINISHED));
+ }
+
+/*****************************************************************/
+/* s_func=DO_OPT_FLG */
+/* */
+/* from list: */
+/* if (m_msg.stages > 1) do_opt() */
+/* do_walign() */
+/* calc_id or calc_code, no calcons */
+/*****************************************************************/
+
+ /* s_func == 1 means do_opt if necessary */
+ else if (qm_msg.s_func== DO_OPT_FLG) { /* qm_msg.slist > 0 */
+#ifdef DEBUG
+ fprintf(stderr," [%d] starting s_func:1 slist: %d\n",
+ worker,qm_msg.slist);
+#endif
+ /* get the buffer once - re-use it for the entire slist */
+ if (m_msg.show_code == SHOW_CODE_ALIGN) {
+ seqc_buff_len = (BFR2+5)*256;
+ seqc = seqc_buff = (char *)calloc(seqc_buff_len,sizeof(char));
+ seqc_buff_cnt = 0;
+ if (seqc_buff == NULL) {
+ seqc_buff_cnt = seqc_buff_len = 0;
+ }
+ }
+
+ bestcnt = 0;
+ for (count=0; count < qm_msg.slist; count++) {
+ rst.score[0] = rst.score[1] = rst.score[2] = 0;
+ itt = liblist[count].frame;
+ seqnm = liblist[count].seqnm;
+
+ bestr2[bestcnt].seqnm = seqnm;
+ bestr2[bestcnt].m_seqnm = seqpt[seqnm].m_seqnm;
+ if (m_msg.stages > 1) {
+ do_opt (aa0[itt], qm_msg.n0, seqpt[seqnm].aa1,
+ seqpt[seqnm].n1, itt,
+ &pst, f_str[itt], &rst);
+
+ bestr2[bestcnt].score[0] = rst.score[0];
+ bestr2[bestcnt].score[1] = rst.score[1];
+ bestr2[bestcnt].score[2] = rst.score[2];
+ }
+
+ if (m_msg.markx & MX_M9SUMM) {
+#ifdef DEBUG
+ fprintf(stderr," [%d] starting do_walign seqnm: %d n1: %d\n",
+ worker,seqnm,seqpt[seqnm].n1);
+#endif
+ aln_dp = &bestr2[bestcnt].aln_d;
+ memcpy(aln_dp, &aln,sizeof(struct a_struct));
+
+ sw_score = do_walign(aa0[itt], qm_msg.n0,
+ seqpt[seqnm].aa1, seqpt[seqnm].n1,
+ itt, &pst, f_str[itt],
+ &seqpt[seqnm].a_res[itt],
+ &have_walign);
+ seqpt[seqnm].sw_score[itt] = sw_score;
+
+ /* the a_res[itt] provided by do_walign is re-used - so it
+ must be copied to a valid location */
+
+ if (have_walign) {
+ if ((tres = calloc(seqpt[seqnm].a_res[itt].nres+1,sizeof(int)))==NULL) {
+ w_abort(" cannot allocate tres");
+ }
+ else {
+ memcpy(tres,seqpt[seqnm].a_res[itt].res,sizeof(int)*seqpt[seqnm].a_res[itt].nres);
+ seqpt[seqnm].a_res[itt].res = tres;
+ /*
+ fprintf(stderr, " [%d] saving %d:%d[%d]:%o\n", worker,
+ walign_cnt[itt],seqnm,itt, seqpt[seqnm].a_res[itt].res);
+ */
+ if (walign_cnt[itt] < lcnt) walign_done[itt][walign_cnt[itt]++] = seqnm;
+ else w_abort(" walign_cnt overrun");
+ seqpt[seqnm].walign_dflg[itt] = 1;
+ }
+ }
+ aln_func_vals(itt, aln_dp);
+
+#ifdef DEBUG
+ fprintf(stderr," [%d] starting calc_id sw_score: %d\n",
+ worker,sw_score);
+ fprintf(stderr,"bi: %d seqc_buff_cnt: %d - seqc_buff_len: %d\n",
+ bestcnt, seqc_buff_cnt, seqc_buff_len);
+#endif
+ aln_code_n = 0; /* must be set in case no seqc_code */
+ if (m_msg.show_code == SHOW_CODE_ALIGN) {
+ if (seqc_buff_cnt < seqc_buff_len - 256) {
+ lc=calc_code(aa0[itt],qm_msg.n0,
+ seqpt[seqnm].aa1, seqpt[seqnm].n1,
+ aln_dp,seqpt[seqnm].a_res[itt],pst,
+ seqc,seqc_buff_len-seqc_buff_cnt-10,
+ f_str[itt]);
+ aln_code_n = strlen(seqc);
+ seqc_buff_cnt += aln_code_n + 1;
+/*
+ fprintf(stderr,"%d:%d:%d: %d/%d - [%d] %s\n",
+ worker,seqnm,bestcnt,aln_code_n,seqc_buff_cnt, seqc-seqc_buff,seqc);
+*/
+ seqc += aln_code_n;
+ *seqc++ = '\0';
+ }
+ }
+ else {
+ lc=calc_id(aa0[itt],qm_msg.n0,
+ seqpt[seqnm].aa1, seqpt[seqnm].n1,
+ aln_dp,seqpt[seqnm].a_res[itt],pst,f_str[itt]);
+ }
+
+ nident = aln_dp->nident;
+ aln_dp->a_len = lc;
+
+ if (lc > 0) percent = (100.0*(float)nident)/(float)lc;
+ else percent = 0.0;
+
+ ngap = aln_dp->ngap_q + aln_dp->ngap_l;
+#ifndef SHOWSIM
+ if (lc-ngap > 0) gpercent = (100.0*(float)nident)/(float)(lc-ngap);
+#else
+ if (lc > 0) gpercent =(100.0*(float)aln_dp->nsim)/(float)lc;
+#endif
+ else gpercent = -1.0;
+
+ bestr2[bestcnt].sw_score = sw_score;
+ bestr2[bestcnt].percent = percent;
+ bestr2[bestcnt].gpercent = gpercent;
+ bestr2[bestcnt].aln_code_n = aln_code_n;
+ }
+ bestcnt++;
+
+ if (bestcnt >= BFR2) {
+ send_bestr2(hosttid,bestr2,bestcnt);
+ if (m_msg.show_code == SHOW_CODE_ALIGN) {
+ send_code(hosttid,seqc_buff,seqc_buff_cnt);
+ memset(seqc_buff,0,seqc_buff_len);
+ seqc = seqc_buff;
+ seqc_buff_cnt = 0;
+ }
+ bestcnt = 0;
+ }
+ } /* END - for count loop */
+
+ send_bestr2(hosttid,bestr2,(bestcnt|FINISHED));
+ if (m_msg.show_code == SHOW_CODE_ALIGN) {
+ send_code(hosttid,seqc_buff,seqc_buff_cnt);
+ if (seqc_buff) free(seqc_buff);
+ }
+ }
+ /* get alignments */
+
+/*****************************************************************/
+/* s_list > */
+/* s_func=DO_ALIGN_FLG */
+/* */
+/* from list: */
+/* do_walign() if not done already */
+/* calcons() */
+/*****************************************************************/
+
+ else if (qm_msg.s_func==DO_ALIGN_FLG) {
+ for (count=0; count < qm_msg.slist; count++) {
+ itt = liblist[count].frame;
+ seqnm = liblist[count].seqnm;
+/*
+ fprintf(stderr,"worker: %d; %s, frame: %d\n",worker,qm_msg.libstr,itt);
+*/
+ if (!seqpt[seqnm].walign_dflg[itt]) {
+ seqpt[seqnm].sw_score[itt] =
+ sw_score = do_walign (aa0[itt], qm_msg.n0,seqpt[seqnm].aa1,
+ seqpt[seqnm].n1, itt,
+ &pst, f_str[itt],
+ &seqpt[seqnm].a_res[itt],
+ &have_walign);
+ }
+ else {
+ sw_score = seqpt[seqnm].sw_score[itt];
+ pre_cons(seqpt[seqnm].aa1,seqpt[seqnm].n1,itt,f_str[itt]);
+ }
+
+ aln_func_vals(itt, &aln);
+
+ if (aln.showall==1)
+ maxc = seqpt[seqnm].a_res[itt].nres + max(seqpt[seqnm].a_res[itt].min0,seqpt[seqnm].a_res[itt].min1)+
+ max((qm_msg.n0-seqpt[seqnm].a_res[itt].max0),
+ (seqpt[seqnm].n1-seqpt[seqnm].a_res[itt].max1))+4;
+ else maxc = seqpt[seqnm].a_res[itt].nres + 4*aln.llen+4;
+
+ initseq(&seqc0, &seqc0a, &seqc1, &seqca, maxc);
+
+ if (!m_msg.ann_flg) {
+ nc=calcons(aa0[itt],qm_msg.n0,
+ seqpt[seqnm].aa1, seqpt[seqnm].n1,
+ &lc,&aln,seqpt[seqnm].a_res[itt],pst,
+ seqc0,seqc1,seqca,f_str[itt]);
+ memset(seqc0a,' ',nc);
+ seqc0a[nc]='\0';
+ }
+ else {
+ nc=calcons_a(aa0[itt],m_msg.aa0a,qm_msg.n0,
+ seqpt[seqnm].aa1, seqpt[seqnm].n1,
+ &lc,&aln,seqpt[seqnm].a_res[itt],pst,
+ seqc0,seqc0a,seqc1,seqca,
+ m_msg.ann_arr,f_str[itt]);
+ }
+
+ /*
+ fprintf(stderr,"[%d] nident: %d nsim: %d lc: %d\n",aln.nident, aln.nsim, lc);
+ */
+
+ maxc = max(strlen(seqc0),strlen(seqc1))+1;
+ nident = aln.nident;
+ percent = (100.0*(float)nident)/(float)lc;
+ ngap = aln.ngap_q+aln.ngap_l;
+#ifndef SHOWSIM
+ if (lc-ngap > 0) gpercent = (100.0*(float)nident)/(float)(lc-ngap);
+#else
+ if (lc > 0) gpercent = (100.0*(float)aln.nsim)/(float)lc;
+#endif
+ else gpercent = -1.0;
+
+#ifdef PVM_SRC
+ pvm_initsend(PvmDataRaw);
+ pvm_pkint(&nc,1,1);
+ pvm_pkint(&lc,1,1);
+ pvm_pkint(&maxc,1,1);
+ pvm_pkfloat(&percent,1,1);
+ pvm_pkfloat(&gpercent,1,1);
+ pvm_pkint(&sw_score,1,1);
+ pvm_pkbyte((char *)&aln,sizeof(struct a_struct),1);
+ pvm_send(hosttid,ALN1TYPE);
+#ifdef DEBUG
+ fprintf(stderr,"[%d] ALN1TYPE sent: %d\n",worker,qm_msg.n0);
+#endif
+ pvm_initsend(PvmDataRaw);
+ pvm_pkbyte(seqc0,maxc,1);
+ if (m_msg.ann_flg) pvm_pkbyte(seqc0a,maxc,1);
+ pvm_pkbyte(seqc1,maxc,1);
+ pvm_pkbyte(seqca,maxc,1);
+ pvm_send(hosttid,ALN2TYPE);
+#endif
+#ifdef MPI_SRC
+ last_msg_b[0]=nc;
+ last_msg_b[1]=lc;
+ last_msg_b[2]=maxc;
+ last_msg_b[3]=sw_score;
+ MPI_Send(last_msg_b,4,MPI_INT,hosttid,ALN1TYPE,MPI_COMM_WORLD);
+ MPI_Send(&percent,1,MPI_FLOAT,hosttid,ALN2TYPE,MPI_COMM_WORLD);
+ MPI_Send(&gpercent,1,MPI_FLOAT,hosttid,ALN2TYPE,MPI_COMM_WORLD);
+
+/* p4_dprintf("[%d] sending aln\n",worker); */
+ MPI_Send(&aln,sizeof(struct a_struct),MPI_BYTE,hosttid,
+ ALN3TYPE,MPI_COMM_WORLD);
+
+ MPI_Send(seqc0,maxc,MPI_BYTE,hosttid,ALN2TYPE,MPI_COMM_WORLD);
+ if (m_msg.ann_flg) MPI_Send(seqc0a,maxc,MPI_BYTE,hosttid,ALN2TYPE,MPI_COMM_WORLD);
+ MPI_Send(seqc1,maxc,MPI_BYTE,hosttid,ALN3TYPE,MPI_COMM_WORLD);
+ MPI_Send(seqca,maxc,MPI_BYTE,hosttid,ALN3TYPE,MPI_COMM_WORLD);
+#endif
+ freeseq(&seqc0,&seqc0a,&seqc1,&seqca);
+ }
+ }
+
+/* send back parameter settings */
+ if (worker==FIRSTWORK && qm_msg.slist==0) {
+ get_param(&pst, gstring2,gstring3);
+#ifdef PVM_SRC
+ pvm_initsend(PvmDataRaw);
+ pvm_pkbyte(gstring2,sizeof(gstring2),1);
+ pvm_pkbyte(gstring3,sizeof(gstring3),1);
+ pvm_send(hosttid,PARAMTYPE);
+#endif
+#ifdef MPI_SRC
+ MPI_Send(gstring2,sizeof(gstring2),MPI_BYTE,
+ hosttid,PARAMTYPE,MPI_COMM_WORLD);
+ MPI_Send(gstring3,sizeof(gstring3),MPI_BYTE,
+ hosttid,PARAMTYPE,MPI_COMM_WORLD);
+#endif
+ }
+
+ if (qm_msg.slist==0) {
+ if (curtype == ONETYPE) curtype = TWOTYPE;
+ else curtype = ONETYPE;
+ }
+ } /* END - while (1) loop */
+#ifdef PVM_SRC
+ pvm_exit();
+#endif
+#ifdef MPI_SRC
+/* MPI_Finalize(); */
+#endif
+}
+
+void
+send_bestr(int hosttid, int curtype,
+ struct comstr *bestr, int buf_size, int lastcnt) {
+
+ bestr[buf_size].seqnm = lastcnt;
+#ifdef PVM_SRC
+ pvm_initsend(PvmDataRaw);
+ pvm_pkbyte((char *)&bestr[0],sizeof(struct comstr)*(buf_size+1),1);
+ pvm_send(hosttid,curtype);
+#endif
+#ifdef MPI_SRC
+ MPI_Send(bestr,sizeof(struct comstr)*(buf_size+1),MPI_BYTE,
+ hosttid,curtype,MPI_COMM_WORLD);
+#endif
+}
+
+void
+send_bestr2(int hosttid, struct comstr2 *bestr2,
+ int lastcnt)
+{
+ bestr2[BFR2].seqnm = lastcnt;
+#ifdef PVM_SRC
+ pvm_initsend(PvmDataRaw);
+ pvm_pkbyte((char *)&bestr2[0],sizeof(struct comstr2)*(BFR2+1),1);
+ pvm_send(hosttid,LISTRTYPE);
+#endif
+#ifdef MPI_SRC
+ MPI_Send(&bestr2[0],sizeof(struct comstr2)*(BFR2+1),MPI_BYTE,
+ hosttid,LISTRTYPE,MPI_COMM_WORLD);
+#endif
+}
+
+void
+send_code(int hosttid, char *seqc_buff, int seqc_buff_len) {
+
+#ifdef PVM_SRC
+ pvm_initsend(PvmDataRaw);
+ pvm_pkint(&seqc_buff_len,1,1);
+ if (seqc_buff_len > 0) pvm_pkbyte(seqc_buff,seqc_buff_len,1);
+ pvm_send(hosttid,CODERTYPE);
+#endif
+#ifdef MPI_SRC
+ MPI_Send(&seqc_buff_len,1,MPI_INT,
+ hosttid,CODERTYPE,MPI_COMM_WORLD);
+ if (seqc_buff_len>0) MPI_Send(seqc_buff,seqc_buff_len,MPI_BYTE,
+ hosttid,CODERTYPE,MPI_COMM_WORLD);
+#endif
+}
+
+#ifdef PVM_SRC
+int tidtonode(tid)
+ int tid;
+{
+ int i;
+ for (i=FIRSTNODE; i< nnodes; i++) if (tid==pinums[i]) return i;
+ fprintf(stderr," cannot find tid %d\n",tid);
+ return -1;
+}
+#endif
+
+void
+free_ares(struct sqs2 *seqpt, int itt, int *walign_done, int walign_cnt, int worker) {
+
+ int i, seqnm;
+
+ for (i=0; i< walign_cnt; i++) {
+ seqnm = walign_done[i];
+ walign_done[i]=0;
+ if (seqpt[seqnm].walign_dflg[itt]) {
+ if (seqpt[seqnm].a_res[itt].nres > 0 ) {
+ /*
+ fprintf(stderr, "[%d] freeing %d:%d[%d]:%o\n",
+ worker,i,seqnm,itt,seqpt[seqnm].a_res[itt].res);
+ */
+ seqpt[seqnm].a_res[itt].nres = 0;
+ free(seqpt[seqnm].a_res[itt].res);
+ }
+ }
+ else {
+ w_abort(" have walign_done but no walign_dflag");
+ }
+ seqpt[seqnm].walign_dflg[itt] = 0;
+ }
+}
git://source.jalview.org / jabaws.git / blobdiff