예제 #1
0
static void nss_setpwent(void)
{
	NSS_STATUS (*_nss_setpwent)(void) = find_fn("setpwent");
	NSS_STATUS status;
	status = _nss_setpwent();
	if (status != NSS_STATUS_SUCCESS) {
		report_nss_error("setpwent", status);
	}
}
예제 #2
0
static void nss_endgrent(void)
{
	NSS_STATUS (*_nss_endgrent)(void) = find_fn("endgrent");
	NSS_STATUS status;

	if (!_nss_endgrent)
		return;

	status = _nss_endgrent();
	if (status != NSS_STATUS_SUCCESS) {
		report_nss_error("endgrent", status);
	}
}
예제 #3
0
static int nss_initgroups(char *user, gid_t group, gid_t **groups, long int *start, long int *size)
{
	NSS_STATUS (*_nss_initgroups)(char *, gid_t , long int *,
				      long int *, gid_t **, long int , int *) = 
		find_fn("initgroups_dyn");
	NSS_STATUS status;

	if (!_nss_initgroups) return NSS_STATUS_UNAVAIL;

	status = _nss_initgroups(user, group, start, size, groups, 0, &nss_errno);
	if (status != NSS_STATUS_SUCCESS) {
		report_nss_error("initgroups", status);
	}
	return status;
}
예제 #4
0
파일: nsstest.c 프로젝트: tridge/junkcode
static struct passwd *nss_getpwnam(const char *name)
{
	NSS_STATUS (*_nss_getpwnam_r)(const char *, struct passwd *, char *, 
				      size_t , int *) = find_fn("getpwnam_r");
	static struct passwd pwd;
	static char buf[1000];
	NSS_STATUS status;
	
	status = _nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &nss_errno);
	if (status == NSS_STATUS_NOTFOUND) {
		return NULL;
	}
	if (status != NSS_STATUS_SUCCESS) {
		report_nss_error("getpwnam", status);
		return NULL;
	}
	return &pwd;
}
예제 #5
0
static void* singleListFind(const void*_self, Find_FN find_fn, va_list *params) {
    const _SingleList *self = _self;
    Node **p = &self->head->next;
    void *node = NULL;
    
    for (; (*p) != NULL; p = &(*p)->next) {
        va_list args;
        va_copy(args, *params);        
        node = find_fn((*p)->data, &args);
        va_end(args);

        if (node != NULL) {
            return node;
        }
    }

    return NULL;
}
예제 #6
0
static struct passwd *nss_getpwent(void)
{
	NSS_STATUS (*_nss_getpwent_r)(struct passwd *, char *, 
				      size_t , int *) = find_fn("getpwent_r");
	static struct passwd pwd;
	static char buf[1000];
	NSS_STATUS status;

	if (!_nss_getpwent_r)
		return NULL;

	status = _nss_getpwent_r(&pwd, buf, sizeof(buf), &nss_errno);
	if (status == NSS_STATUS_NOTFOUND) {
		return NULL;
	}
	if (status != NSS_STATUS_SUCCESS) {
		report_nss_error("getpwent", status);
		return NULL;
	}
	return &pwd;
}
예제 #7
0
static const char *_find_config_str(const void *start, node_lookup_fn find_fn,
				    const char *path, const char *fail, int allow_empty)
{
	const struct dm_config_node *n = find_fn(start, path);

	/* Empty strings are ignored if allow_empty is set */
	if (n && n->v) {
		if ((n->v->type == DM_CFG_STRING) &&
		    (allow_empty || (*n->v->v.str))) {
			log_very_verbose("Setting %s to %s", path, n->v->v.str);
			return n->v->v.str;
		}
		if ((n->v->type != DM_CFG_STRING) || (!allow_empty && fail))
			log_warn("WARNING: Ignoring unsupported value for %s.", path);
	}

	if (fail)
		log_very_verbose("%s not found in config: defaulting to %s",
				 path, fail);
	return fail;
}
예제 #8
0
void find_n_half(double maxbw, int num_pairs, char *s_buf, 
                 char *r_buf, int myid)
{
  double bw = 0.0, error;
  int size = 1, lastsize = 0, top=0, bottom=0, tmp;
  error = (maxbw / 100) * N_HALF_ERROR_BOUND;
  if (myid == 0)
  {
    fprintf(stdout, "Searching for N/2 bandwidth.  Maximum ");
    fprintf(stdout, "Bandwidth of %f MB/s", maxbw);
    fprintf(stdout, "...\n");
    fflush(stdout);
  }
  while ( (size != lastsize) && (size <= MAX_MSG_SIZE) &&
        (bw < (maxbw / 2 - error) || bw > (maxbw / 2 + error)))
  {
    bw = find_fn (size, num_pairs, s_buf, r_buf); 
    if (myid == 0)
    {
      if (bw < (maxbw / 2 - error))
      {
        tmp = size;
        if (lastsize > size || top) /*We have a top! */
        {
          if (lastsize > size) 
          {
            top = lastsize;
          }
          size = size + (top - size) / 2;
        }
        else /*Still searching for a top */
        {
          size = size << 1 ;
        }
        lastsize = tmp;
      }
      if( bw > (maxbw / 2 + error))
      {
        tmp = size;
        if (lastsize < size)
        {
          bottom = lastsize;
        }
        size = size - (size - bottom) / 2;
        lastsize = tmp;
      }
    }
    MPI_Bcast (&size, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast (&lastsize, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast (&bw, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
  }
  if (myid == 0)
  {
    if (size > MAX_MSG_SIZE) {
        fprintf (stdout, "Unable to find N/2 bandwidth in sizes");
        fprintf (stdout, " from 0 to %d bytes\n", MAX_MSG_SIZE);
    }
    else {
        fprintf (stdout, "Found N/2 bandwidth of %f MB/s at size",bw);
        fprintf (stdout, " %i bytes\n", size); 
    }
  }
  MPI_Barrier (MPI_COMM_WORLD);
  return;
}
예제 #9
0
int main(int argc, char *argv[])
{

  int myid, num_procs, num_pairs=0, i;
  int size, align_size, org_method = AUTOMATIC;
  char *s_buf, *r_buf;
  double maxbw=0.0, bw=0.0;
  
  MPI_Init(&argc, &argv);
  for (i = 0; i < MAX_PROCS; i++)
  {
    /*initialize to -1 because it is outside the legal range for ranks*/
    pair_list[i].sender = -1;
    pair_list[i].receiver = -1;
  }
  MPI_Comm_size (MPI_COMM_WORLD, &num_procs);
  MPI_Comm_rank (MPI_COMM_WORLD, &myid);

  while ( (i = getopt(argc, argv, "-bhm:")) != -1)
  {
    switch(i)
    {
      case 'b':
	find_fn = find_bibw;
	break;
      case 'h':
        if (myid == 0)
        {
          usage();
          MPI_Abort(MPI_COMM_WORLD, 0);
        }
        break;
      case 'm':
        org_method = MANUAL;
        num_pairs = (int)strtoul(optarg, NULL, 0);
        if ((num_pairs < 1))
        {
          if (myid == 0) {
            fprintf(stderr, "procs/node must be >= 1\n");
            usage();
          }
          MPI_Abort(MPI_COMM_WORLD, 1);
        } 
        break;
      default:
        if ((!optopt) && (!num_pairs) && (strtoul(optarg,NULL,0)))
        {
          num_pairs = (int) strtoul(optarg, NULL, 0);
        }         
        else
        { 
          if (myid == 0)
          {
            usage();
            MPI_Abort(MPI_COMM_WORLD, 1);
          }
        }
     }
  }    

  if(org_method == AUTOMATIC)
  {
    num_pairs = set_pair_list(num_pairs);
  }
  else
  {
    /*do the simple way */
    for (i = 0; i < num_pairs; i++)
    {
      pair_list[i].sender = i;
      pair_list[i + num_pairs].sender = i;
      pair_list[i].receiver = i + num_pairs; 
      pair_list[i + num_pairs].receiver = i + num_pairs;
    } 
    for (i = num_pairs*2; i < num_procs; i++)
    {
      pair_list[i].sender = -1;
      pair_list[i].receiver = -1;
    }
  }
  align_size = getpagesize();
  s_buf =
      (char *) (((unsigned long) s_buf1 + (align_size - 1)) /
                align_size * align_size);
  r_buf =
      (char *) (((unsigned long) r_buf1 + (align_size - 1)) /
                align_size * align_size);
  if (myid == 0) 
  {
    fprintf(stdout, "# PathScale Modified OSU MPI Bandwidth Test\n");
    fprintf(stdout, "(OSU Version 2.2, PathScale $Revision: 1.4 $)\n");
    fprintf(stdout, "# Running on %d procs per node"
            " (%s traffic for each process pair)\n",
            num_pairs,
	    (find_fn == find_bw) ? "uni-directional" : "bi-directional");
    fprintf(stdout, "# Size\t\tAggregate Bandwidth (MB/s)\tMessages/s \n");
  }
  MPI_Barrier (MPI_COMM_WORLD);
  MPI_Comm_split(MPI_COMM_WORLD, pair_list[myid].sender == myid,
                 myid, &mpi_comm_sender);
    /* Loop over bandwidth test */
  for (size = 1; size <= MAX_MSG_SIZE; size *= 2)
  {
    /*Pulled out message test code into function find_bw/find_bibw*/
    bw=find_fn(size, num_pairs, s_buf, r_buf);
    if (myid == 0)
    {
      double rate;
      rate = 1000*1000*bw/size;
      fprintf(stdout, "%d\t\t%f\t\t\t%f\n", size, bw, rate);
      fflush(stdout);
      if(bw>maxbw) /*keep track of maximum bandwidth for N/2*/
      {
        maxbw=bw;
      }
    }
  }
  MPI_Bcast(&maxbw,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
  find_n_half(maxbw, num_pairs, s_buf, r_buf, myid);
  MPI_Finalize();
  return 0;
}
예제 #10
0
static const struct dm_config_node *_find_config_node(const void *start, const char *path) {
	struct dm_config_node dummy = { .child = (void *) start };
	return _find_or_make_node(NULL, &dummy, path);
}

static const struct dm_config_node *_find_first_config_node(const void *start, const char *path)
{
	const struct dm_config_tree *cft = start;
	const struct dm_config_node *cn = NULL;

	while (cft) {
		if ((cn = _find_config_node(cft->root, path)))
			return cn;
		cft = cft->cascade;
	}

	return NULL;
}

static const char *_find_config_str(const void *start, node_lookup_fn find_fn,
				    const char *path, const char *fail, int allow_empty)
{
	const struct dm_config_node *n = find_fn(start, path);

	/* Empty strings are ignored if allow_empty is set */
	if (n && n->v) {
		if ((n->v->type == DM_CFG_STRING) &&
		    (allow_empty || (*n->v->v.str))) {
			log_very_verbose("Setting %s to %s", path, n->v->v.str);
			return n->v->v.str;
		}
		if ((n->v->type != DM_CFG_STRING) || (!allow_empty && fail))
			log_warn("WARNING: Ignoring unsupported value for %s.", path);
	}

	if (fail)
		log_very_verbose("%s not found in config: defaulting to %s",
				 path, fail);
	return fail;
}

const char *dm_config_find_str(const struct dm_config_node *cn,
			       const char *path, const char *fail)
{
	return _find_config_str(cn, _find_config_node, path, fail, 0);
}

const char *dm_config_find_str_allow_empty(const struct dm_config_node *cn,
					   const char *path, const char *fail)
{
	return _find_config_str(cn, _find_config_node, path, fail, 1);
}

static int64_t _find_config_int64(const void *start, node_lookup_fn find,
				  const char *path, int64_t fail)
{
	const struct dm_config_node *n = find(start, path);

	if (n && n->v && n->v->type == DM_CFG_INT) {
		log_very_verbose("Setting %s to %" PRId64, path, n->v->v.i);
		return n->v->v.i;
	}

	log_very_verbose("%s not found in config: defaulting to %" PRId64,
			 path, fail);
	return fail;
}

static float _find_config_float(const void *start, node_lookup_fn find,
				const char *path, float fail)
{
	const struct dm_config_node *n = find(start, path);

	if (n && n->v && n->v->type == DM_CFG_FLOAT) {
		log_very_verbose("Setting %s to %f", path, n->v->v.f);
		return n->v->v.f;
	}

	log_very_verbose("%s not found in config: defaulting to %f",
			 path, fail);

	return fail;

}

static int _str_in_array(const char *str, const char * const values[])
{
	int i;

	for (i = 0; values[i]; i++)
		if (!strcasecmp(str, values[i]))
			return 1;

	return 0;
}