Esempio n. 1
0
int bound_mpi_int(int boundstage, int boundvartype, PFTYPE (*prim)[NSTORE2][NSTORE3][NUMPFLAGS])
{
  int dir;

#if(USEMPI)
  /* These arrays contain designations that identify 
   * each recv and send */
  static MPI_Request requests[COMPDIM * 2 * 2];
  // format of map for requests[dir*2+recv/send(0/1)]
#endif

#if(USEMPI)

  ///////////////
  // dir=1  
  if((boundstage==STAGE0)||(boundstage==STAGEM1)){
    for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) pack_int(dir,boundvartype,prim,workbc_int);
    for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendrecv_int(dir,boundvartype,workbc_int,requests);
  }
  if((boundstage==STAGE1)||(boundstage==STAGEM1)){
    for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) recvwait(dir,requests);
    for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim);
    for(dir=X1UP;dir<=X1DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests);
  }

  ///////////////
  // dir=2
  if((boundstage==STAGE2)||(boundstage==STAGEM1)){
    for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) pack_int(dir,boundvartype,prim,workbc_int);
    for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendrecv_int(dir,boundvartype,workbc_int,requests);
  }
  if((boundstage==STAGE3)||(boundstage==STAGEM1)){
    for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) recvwait(dir,requests);
    for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim);
    for(dir=X2UP;dir<=X2DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests);
  }

  ///////////////
  // dir=3
  if((boundstage==STAGE4)||(boundstage==STAGEM1)){
    for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) pack_int(dir,boundvartype,prim,workbc_int);
    for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendrecv_int(dir,boundvartype,workbc_int,requests);
  }
  if((boundstage==STAGE5)||(boundstage==STAGEM1)){
    for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) recvwait(dir,requests);
    for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim);
    for(dir=X3UP;dir<=X3DN;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests);
  }


  // now corner zones will be filled correctly
  // GODMARK: If made fixup_utoprim() and check_solution() not use corner zones could bound all directions at once -- probably not important performance hit


  // end if mpi
#endif

  return(0);

}	
Esempio n. 2
0
/*
 *  read configuration sent by scanner and populate "config" in
 *  ENGINE_USER structure
 */
static int init_unpack(ENGINE_USER * usr, char * buffer, int size)
{
    EC_CONFIG * cfg = usr->config;
    int ofs = 0;
    int tag = unpack_int(buffer, &ofs);
    assert(tag == MSG_CONFIG);
    int scanner_config_size = unpack_int(buffer, &ofs);
    read_config(buffer + ofs, scanner_config_size, cfg);
    ofs += scanner_config_size;
    int mapping_config_size = unpack_int(buffer, &ofs);
    parseEntriesFromBuffer(buffer + ofs, mapping_config_size, cfg);

    ELLNODE * node;
    for(node = ellFirst(&cfg->devices); node; node = ellNext(node))
    {
        EC_DEVICE * device = (EC_DEVICE *)node;
        printf("%s\n", device->name);
        ELLNODE * node1;
        for(node1 = ellFirst(&device->pdo_entry_mappings); node1; node1 = ellNext(node1))
        {
            EC_PDO_ENTRY_MAPPING * mapping = (EC_PDO_ENTRY_MAPPING *)node1;
            if(strcmp(mapping->pdo_entry->name, mapping->pdo_entry->parent->name) == 0)
            {
                printf("  %s\n", mapping->pdo_entry->name);
            }
            else
            {
                printf("  %s %s\n", mapping->pdo_entry->parent->name, mapping->pdo_entry->name);
            }
        }
    }
    return 0;
}
Esempio n. 3
0
/* unpack sphere from double and integer buffers (unpacking starts at dpos and ipos in
 * d and i and no more than a specific number of doubles and ints can be red) */
SPHERE* SPHERE_Unpack (void *solfec, int *dpos, double *d, int doubles, int *ipos, int *i, int ints)
{
  SPHERE *sph;
  int j;

  ERRMEM (sph = MEM_CALLOC (sizeof (SPHERE)));

  sph->surface = unpack_int (ipos, i, ints);
  sph->volume = unpack_int (ipos, i, ints);

  unpack_doubles (dpos, d, doubles, sph->cur_center, 3);
  unpack_doubles (dpos, d, doubles, (double*)sph->cur_point, 9);
  sph->cur_radius = unpack_double  (dpos, d, doubles);

  unpack_doubles (dpos, d, doubles, sph->ref_center, 3);
  unpack_doubles (dpos, d, doubles, (double*)sph->ref_point, 9);
  sph->ref_radius = unpack_double  (dpos, d, doubles);

  j = unpack_int (ipos, i, ints); /* unpack material existence flag */

  if (j)
  {
    SOLFEC *sol = solfec;
    char *label = unpack_string (ipos, i, ints);
    ASSERT_DEBUG_EXT (sph->mat = MATSET_Find (sol->mat, label), "Failed to find material when unpacking a sphere");
    free (label);
  }

  return sph;
}
Esempio n. 4
0
static void handle_resize(struct tmate_session *session,
			  struct tmate_unpacker *uk)
{
	session->min_sx = unpack_int(uk);
	session->min_sy = unpack_int(uk);
	recalculate_sizes();
}
Esempio n. 5
0
/* unpack ellipsoid from double and integer buffers (unpacking starts at dpos and ipos in
 * d and i and no more than a specific number of doubles and ints can be red) */
ELLIP* ELLIP_Unpack (void *solfec, int *dpos, double *d, int doubles, int *ipos, int *i, int ints)
{
  ELLIP *eli;
  int j;

  ERRMEM (eli = MEM_CALLOC (sizeof (ELLIP)));

  eli->surface = unpack_int (ipos, i, ints);
  eli->volume = unpack_int (ipos, i, ints);

  unpack_doubles (dpos, d, doubles, eli->cur_center, 3);
  unpack_doubles (dpos, d, doubles, (double*)eli->cur_point, 9);

  unpack_doubles (dpos, d, doubles, eli->ref_center, 3);
  unpack_doubles (dpos, d, doubles, (double*)eli->ref_point, 9);

  unpack_doubles (dpos, d, doubles, eli->ref_sca, 3);
  unpack_doubles (dpos, d, doubles, eli->ref_rot, 9);

  unpack_doubles (dpos, d, doubles, eli->cur_sca, 3);
  unpack_doubles (dpos, d, doubles, eli->cur_rot, 9);

  j = unpack_int (ipos, i, ints); /* unpack material existence flag */

  if (j)
  {
    SOLFEC *sol = solfec;
    char *label = unpack_string (ipos, i, ints);
    ASSERT_DEBUG_EXT (eli->mat = MATSET_Find (sol->mat, label), "Failed to find material when unpacking a eliere");
    free (label);
  }

  return eli;
}
Esempio n. 6
0
static void tmate_client_resize(struct tmate_unpacker *uk)
{
	/* TODO This is sad, we might want our own client. */
	tmate_sx = unpack_int(uk);
	tmate_sy = unpack_int(uk);
	recalculate_sizes();

	/* TODO Handle reconnection cases */
}
Esempio n. 7
0
int bound_mpi_int(int boundstage, int prim[][N2M][N3M][NUMPFLAGS])
{
  int dir;

#if(USEMPI)
  /* These arrays contain designations that identify 
   * each recv and send */
  static MPI_Request requests[COMPDIM * 2 * 2];
  // format of map for requests[dir*2+recv/send(0/1)]
#endif

#if(USEMPI)

  
  if((boundstage==STAGE0)||(boundstage==STAGEM1)){
    for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) pack_int(dir,prim,workbc_int);
    for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendrecv_int(dir,workbc_int,requests);
  }
  if((boundstage==STAGE1)||(boundstage==STAGEM1)){
    for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) recvwait(dir,requests);
    for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) unpack_int(dir,workbc_int,prim);
    for(dir=X1UP;dir<=X1DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendwait(dir,requests);
  }

  if((boundstage==STAGE2)||(boundstage==STAGEM1)){
    for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) pack_int(dir,prim,workbc_int);
    for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendrecv_int(dir,workbc_int,requests);
  }
  if((boundstage==STAGE3)||(boundstage==STAGEM1)){
    for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) recvwait(dir,requests);
    for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) unpack_int(dir,workbc_int,prim);
    for(dir=X2UP;dir<=X2DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendwait(dir,requests);
  }

  if((boundstage==STAGE4)||(boundstage==STAGEM1)){
    for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) pack_int(dir,prim,workbc_int);
    for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendrecv_int(dir,workbc_int,requests);
  }
  if((boundstage==STAGE5)||(boundstage==STAGEM1)){
    for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) recvwait(dir,requests);
    for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) unpack_int(dir,workbc_int,prim);
    for(dir=X3UP;dir<=X3DN;dir++) if(dirset[BOUNDPRIMTYPE][dir][DIRIF]) sendwait(dir,requests);
  }



  // end if mpi
#endif

  return(0);

}	
Esempio n. 8
0
static void handle_exec_cmd_str(__unused struct tmate_session *session,
				struct tmate_unpacker *uk)
{
	struct cmd_q *cmd_q;
	struct cmd_list *cmdlist;
	char *cause;
	u_int i;

	int client_id = unpack_int(uk);
	char *cmd_str = unpack_string(uk);

	if (cmd_string_parse(cmd_str, &cmdlist, NULL, 0, &cause) != 0) {
		tmate_failed_cmd(client_id, cause);
		free(cause);
		goto out;
	}

	cmd_q = cmdq_new(NULL);
	cmdq_run(cmd_q, cmdlist, NULL);
	cmd_list_free(cmdlist);
	cmdq_free(cmd_q);

	/* error messages land in cfg_causes */
	for (i = 0; i < cfg_ncauses; i++) {
		tmate_failed_cmd(client_id, cfg_causes[i]);
		free(cfg_causes[i]);
	}

	free(cfg_causes);
	cfg_causes = NULL;
	cfg_ncauses = 0;

out:
	free(cmd_str);
}
Esempio n. 9
0
static void tmate_client_exec_cmd(struct tmate_unpacker *uk)
{
	struct cmd_q *cmd_q;
	struct cmd_list *cmdlist;
	char *cause;

	int client_id = unpack_int(uk);
	char *cmd_str = unpack_string(uk);

	if (cmd_string_parse(cmd_str, &cmdlist, NULL, 0, &cause) != 0) {
		tmate_failed_cmd(client_id, cause);
		free(cause);
		goto out;
	}

	/* error messages land in cfg_causes */
	ARRAY_FREE(&cfg_causes);

	cmd_q = cmdq_new(NULL);
	cmdq_run(cmd_q, cmdlist);
	cmd_list_free(cmdlist);
	cmdq_free(cmd_q);

	if (!ARRAY_EMPTY(&cfg_causes)) {
		cause = ARRAY_ITEM(&cfg_causes, 0);
		tmate_failed_cmd(client_id, cause);
		free(cause);
		ARRAY_FREE(&cfg_causes);
	}

out:
	free(cmd_str);
}
Esempio n. 10
0
ptr<pub3::expr_t>
msgpack_t::unpack_negative_fixnum ()
{
  int8_t b;
  bool ok = unpack_int (&b);
  assert (ok);
  return pub3::expr_int_t::alloc (b);
}
Esempio n. 11
0
int
msa_recv_pkt(msa_pkt_t *pkt, int sfd)
{
    byte_t *dt = 0;
    byte_t st_u = 0;
    size_t st_sz = 0, id_sz = 0, sz_sz = 0;
    unsigned int id_u = 0, sz_u = 0;

    assert(sfd >= 0);

    st_sz = sizeof(byte_t);
    id_sz = sizeof(int);
    sz_sz = sizeof(int);
    
    dt = malloc(st_sz);
    msa_recv_all(sfd, dt, st_sz);
    st_u = unpack_byte(dt);
    pkt->st = st_u;
    free(dt); dt = 0;

    dt = malloc(id_sz);
    msa_recv_all(sfd, dt, id_sz);
    id_u = unpack_int(dt);
    pkt->id = id_u;
    free(dt); dt = 0;
    
    dt = malloc(sz_sz);
    msa_recv_all(sfd, dt, sz_sz);
    sz_u = unpack_int(dt);
    pkt->sz = sz_u;
    free(dt); dt = 0;
    
    if (sz_u != 0) {
        dt = malloc(sz_u * sizeof(char));
        msa_recv_all(sfd, dt, sz_u * sizeof(char));
        pkt->da = unpack_str(dt, sz_u * sizeof(char));
        free(dt); dt = 0;
    } else {
        pkt->da = 0;
    }

    return 0; /* do some error checking? */
}
Esempio n. 12
0
static void handle_pane_key(__unused struct tmate_session *_session,
			    struct tmate_unpacker *uk)
{
	struct session *s;
	struct window_pane *wp;

	int pane_id = unpack_int(uk);
	key_code key = unpack_int(uk);

	s = RB_MIN(sessions, &sessions);
	if (!s)
		return;

	wp = find_window_pane(s, pane_id);
	if (!wp)
		return;

	window_pane_key(wp, NULL, s, key, NULL);
}
Esempio n. 13
0
ptr<pub3::expr_t>
msgpack_t::unpack_map32 ()
{
  consume_byte ();
  u_int32_t n;
  bool ok = unpack_int (&n);
  ptr<pub3::expr_t> ret;
  if (ok) {
    ret = unpack_map (n);
  }
  return ret;
}
Esempio n. 14
0
ptr<pub3::expr_t>
msgpack_t::unpack_raw16 ()
{
  consume_byte ();
  u_int16_t s;
  bool ok = unpack_int (&s);
  ptr<pub3::expr_t> ret;
  if (ok) {
    ret = unpack_raw (s);
  }
  return ret;
}
Esempio n. 15
0
ptr<pub3::expr_t> 
msgpack_t::unpack_array16 ()
{
  consume_byte ();
  u_int16_t n;
  bool ok = unpack_int (&n);
  ptr<pub3::expr_t> ret;
  if (ok) {
    ret = unpack_array (n);
  }
  return ret;
}
Esempio n. 16
0
void process_msg(unsigned char *content, int nbytes, message_t type)
{   //place test code for parsing received message here
    printf("recv'd message: ");

    switch(type)
    {
        case HANDSHAKE:
            printf("Handshake from %d\n", unpack_int(content));
            break;
        case CHOKE:
            printf("CHOKE\n");
            break;
        case UNCHOKE:
            printf("UNCHOKE\n");
            break;
        case INTERESTED:
            printf("INTERESTED\n");
            break;
        case NOT_INTERESTED:
            printf("NOT_INTERESTED\n");
            break;
        case HAVE:
            printf("HAVE piece %d\n", unpack_int(content));
            break;
        case BITFIELD:
            printf("BITFIELD: ");
            int i;
            for (i = 0 ; i < g_bitfield_len ; i++) { printf("%X ", content[i]); }
            break;
        case REQUEST:
            printf("REQUEST piece %d\n", unpack_int(content));
            break;
        case PIECE:
            printf("PIECE \n");
            extract_and_save_piece(nbytes, content, 4);
            break;
        default:
            break;
    }
}
Esempio n. 17
0
static void handle_exec_cmd(__unused struct tmate_session *session,
			    struct tmate_unpacker *uk)
{
	struct cmd_q *cmd_q;
	struct cmd_list *cmdlist;
	struct cmd *cmd;
	char *cause;
	u_int i;
	unsigned int argc;
	char **argv;

	int client_id = unpack_int(uk);

	argc = uk->argc;
	argv = xmalloc(sizeof(char *) * argc);
	for (i = 0; i < argc; i++)
		argv[i] = unpack_string(uk);

	cmd = cmd_parse(argc, argv, NULL, 0, &cause);
	if (!cmd) {
		tmate_failed_cmd(client_id, cause);
		free(cause);
		goto out;
	}

	cmdlist = xcalloc(1, sizeof *cmdlist);
	cmdlist->references = 1;
	TAILQ_INIT(&cmdlist->list);
	TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);

	cmd_q = cmdq_new(NULL);
	cmdq_run(cmd_q, cmdlist, NULL);
	cmd_list_free(cmdlist);
	cmdq_free(cmd_q);

	/* error messages land in cfg_causes */
	for (i = 0; i < cfg_ncauses; i++) {
		tmate_failed_cmd(client_id, cfg_causes[i]);
		free(cfg_causes[i]);
	}

	free(cfg_causes);
	cfg_causes = NULL;
	cfg_ncauses = 0;

out:
	cmd_free_argv(argc, argv);
}
Esempio n. 18
0
void tmate_dispatch_slave_message(struct tmate_session *session,
				  struct tmate_unpacker *uk)
{
	int cmd = unpack_int(uk);
	switch (cmd) {
#define dispatch(c, f) case c: f(session, uk); break
	dispatch(TMATE_IN_NOTIFY,		handle_notify);
	dispatch(TMATE_IN_LEGACY_PANE_KEY,	handle_legacy_pane_key);
	dispatch(TMATE_IN_RESIZE,		handle_resize);
	dispatch(TMATE_IN_EXEC_CMD_STR,		handle_exec_cmd_str);
	dispatch(TMATE_IN_SET_ENV,		handle_set_env);
	dispatch(TMATE_IN_READY,		handle_ready);
	dispatch(TMATE_IN_PANE_KEY,		handle_pane_key);
	dispatch(TMATE_IN_EXEC_CMD,		handle_exec_cmd);
	default: tmate_info("Bad message type: %d", cmd);
	}
}
Esempio n. 19
0
static void handle_message(struct tmate_decoder *decoder, msgpack_object obj)
{
	struct tmate_unpacker _uk;
	struct tmate_unpacker *uk = &_uk;

	init_unpacker(uk, obj);

	switch (unpack_int(uk)) {
	case TMATE_NOTIFY:		tmate_notify(uk); break;
	case TMATE_CLIENT_PANE_KEY:	tmate_client_pane_key(uk); break;
	case TMATE_CLIENT_RESIZE:	tmate_client_resize(uk); break;
	case TMATE_CLIENT_EXEC_CMD:	tmate_client_exec_cmd(uk); break;
	case TMATE_CLIENT_ENV:		tmate_client_env(uk); break;
	case TMATE_CLIENT_READY:	tmate_client_ready(decoder, uk); break;
	default:			decoder_error();
	}
}
Esempio n. 20
0
static void tmate_client_pane_key(struct tmate_unpacker *uk)
{
	struct session *s;
	struct window *w;
	struct window_pane *wp;

	int key = unpack_int(uk);

	s = RB_MIN(sessions, &sessions);
	if (!s)
		return;

	w = s->curw->window;
	if (!w)
		return;

	wp = w->active;
	if (!wp)
		return;

	window_pane_key(wp, s, key);
}
Esempio n. 21
0
static void handle_legacy_pane_key(__unused struct tmate_session *_session,
				   struct tmate_unpacker *uk)
{
	struct session *s;
	struct window *w;
	struct window_pane *wp;

	int key = unpack_int(uk);

	s = RB_MIN(sessions, &sessions);
	if (!s)
		return;

	w = s->curw->window;
	if (!w)
		return;

	wp = w->active;
	if (!wp)
		return;

	window_pane_key(wp, NULL, s, key, NULL);
}
Esempio n. 22
0
int bound_mpi_int_dir(int boundstage, int finalstep, int whichdir, int boundvartype, PFTYPE (*prim)[NSTORE2][NSTORE3][NUMPFLAGS])
{
  int dir;
  static MPI_Request requests[COMPDIM * 2 * 2];
  static int didpostrecvs[COMPDIM*2]={0};

  int dirstart,dirfinish;
  if(whichdir==-1 || whichdir==1){ dirstart=X1UP; dirfinish=X1DN;}
  if(whichdir==-2 || whichdir==2){ dirstart=X2UP; dirfinish=X2DN;}
  if(whichdir==-3 || whichdir==3){ dirstart=X3UP; dirfinish=X3DN;}






  ////////////
  //
  // pre-post recv's
  //
  // OPTMARK: Could avoid dir-dependent MPI calls in step_ch.c (currently true!) and post all recv's for all dirs at once.
  // OPTMARK: Or setup MPIFLOWCONTROL==2 or SUPERMPI
  //
  ////////////
  if(whichdir==-1 || whichdir==-2 || whichdir==-3){
    if((boundstage==STAGEM1)||(boundstage==STAGE0)){
      for(dir=dirstart;dir<=dirfinish;dir++){
        if(dirgenset[boundvartype][dir][DIRIF]){
          recvonly_int(dir,boundvartype,workbc_int,requests);
          didpostrecvs[dir]=1;
        }
      }
    }
  }
  else if(whichdir==1 || whichdir==2 || whichdir==3){

    //////////////////
    //
    // per-whichdir (1,2,3) conditionals for bounding.  Assume whichdir=1 done first, then 2, then 3, so that corners are done correctly as done with normal bounds.
    //
    //////////////////
    
    ///////////////////
    //
    // x or y or z -dir
    // once dir=0,1(X1UP,X1DN) is done, so can start 2,3(X2UP,X2DN)
    //
    /////////////////
    if((boundstage==STAGEM1)||(boundstage==STAGE0&&whichdir==1 || boundstage==STAGE2&&whichdir==2 || boundstage==STAGE4&&whichdir==3)){
      for(dir=dirstart;dir<=dirfinish;dir++){
        if(dirgenset[boundvartype][dir][DIRIF]){
          if(didpostrecvs[dir]==0){
            dualfprintf(fail_file,"Did not post recv and tried to already pack: dir=%d\n",dir);
            myexit(234525155);
          }
          pack_int(dir,boundvartype,prim,workbc_int);
        }
      }
      for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendonly_int(dir,boundvartype,workbc_int,requests);
    }
    if((boundstage==STAGEM1)||(boundstage==STAGE1&&whichdir==1 || boundstage==STAGE3&&whichdir==2 || boundstage==STAGE5&&whichdir==3)){
      for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]){
          recvwait(dir,requests);
          didpostrecvs[dir]=0; // done with recv's
        }
      for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]) unpack_int(dir,boundvartype,workbc_int,prim);
      for(dir=dirstart;dir<=dirfinish;dir++) if(dirgenset[boundvartype][dir][DIRIF]) sendwait(dir,requests);
    }
  }
  else{
    dualfprintf(fail_file,"No such whichdir=%d in boundmpiint.c\n",whichdir);
    myexit(1986290387);
  }



  // now corner zones will be filled correctly
  // GODMARK: If made fixup_utoprim() and check_solution() not use corner zones could bound all directions at once -- probably not important performance hit


  return(0);

}