C++ print_stat函数代码示例

std::pair<bool, std::string> get_node_value(zhandle_t* handle, 
                                            const std::string& node,
                                            const std::string& stat_message) {
  char buffer[1024];
  int length = 1024;
  int stat = zoo_get(handle, node.c_str(), 0, buffer, &length, NULL);
  if (stat != ZOK) print_stat(stat, stat_message + " get_node_value", node);
  if (stat != ZOK) return std::pair<bool, std::string>(false, "");

  // we are good here
  if (length <= 1024) {
    // ok. it fit inside the buffer
    // we can return
    if (length < 0) return std::pair<bool, std::string>(true, "");
    else return std::pair<bool, std::string>(true, std::string(buffer, length));
  }
  else {
    while(1) {
      // buffer not long enough. The length parameter constains the actual length 
      // try again. keep looping until we succeed
      char* newbuffer = new char[length]; 
      int stat = zoo_get(handle, node.c_str(), 0, newbuffer, &length, NULL);
      if (stat != ZOK) print_stat(stat, stat_message + " get_node_value", node);
      std::string retval(newbuffer, length);
      delete newbuffer;

      if (stat != ZOK) print_stat(stat, stat_message + " get_node_value", node);
      if (stat != ZOK) return std::pair<bool, std::string>(false, "");
      if (length < 0) return std::pair<bool, std::string>(true, "");
      else return std::pair<bool, std::string>(true, retval);
    }   
  }
}

void oneway_nb_test(int iters, int nbytes, int alignment)
{GASNET_BEGIN_FUNCTION();
    int i;
    int64_t begin, end;
    stat_struct_t st;
    gasnet_handle_t *handles;
    int pad = (alignment % PAGESZ);

	/* initialize statistics */
	init_stat(&st, nbytes, alignment);
	
	handles = (gasnet_handle_t*) test_malloc(sizeof(gasnet_handle_t) * iters);
	
	memset(locbuf+pad, 1, nbytes);

	BARRIER();
	
	if (iamsender) {
		/* measure the throughput of sending a message */
		begin = TIME();
                for (i = 0; i < iters; i++) {
                        handles[i] = gasnet_put_nb_bulk(peerproc, rembuf, locbuf+pad, nbytes);
                }
		gasnet_wait_syncnb_all(handles, iters); 
		end = TIME();
	 	update_stat(&st, (end - begin), iters);
	}
	
	BARRIER();
	
	if (iamsender) {
		print_stat(myproc, &st, "put_nb_bulk throughput", PRINT_THROUGHPUT);
	}	
	
	/* initialize statistics */
	init_stat(&st, nbytes, alignment);

	if (iamsender) {
		/* measure the throughput of receiving a message */
		begin = TIME();
                for (i = 0; i < iters; i++) {
                    handles[i] = gasnet_get_nb_bulk(locbuf, peerproc, rembuf+pad, nbytes);
                } 
		gasnet_wait_syncnb_all(handles, iters); 
		end = TIME();
	 	update_stat(&st, (end - begin), iters);
	}
	
	BARRIER();
	
	if (iamsender) {
		print_stat(myproc, &st, "get_nb_bulk throughput", PRINT_THROUGHPUT);
	}	
	
	test_free(handles);
}

int main() {
  int p[2];
  print_stat("/dev/console",0);
  print_stat("/dev/tty",0);
  print_stat("/dev/null",0);
  pipe(p);
  print_stat("pipe 0",p[0]);
  print_stat("pipe 1",p[1]);
  
  
return 0;
}

/* Print stats as specified on the provided command line. */
void print_stats(int argc, char **argv) {
	int i;

	if (argc == optind) {
		/* Print all stats. */
		for (i = 0; i < num_stats; i++)
			print_stat(&stats[i]);
	} else {
		/* Print selected stats. */
		for (i = optind; i < argc; i++) {
			char *name = argv[i];
			stat key;
			const stat *s, *end;
			int (*compare)(const void *, const void *);

			key.name = name;
			if (name[strlen(name) - 1] == '.')
				compare = stats_compare_prefix;
			else
				compare = stats_compare;

			if (stats == NULL) {
				s = NULL;
			} else {
				s = (const stat *)bsearch(&key, stats,
							  num_stats,
							  sizeof *stats,
							  compare);
			}

			if (s == NULL) {
				printf("Unknown stat %s\n", name);
				continue;
			}

			/* Find the range of stats the user wanted. */
			for (; s >= stats; s--) {
				if (compare(&key, s) != 0)
					break;
			}
			s++;
			for (end = s; end < &stats[num_stats]; end++) {
				if (compare(&key, end) != 0)
					break;
			}

			/* And print them. */
			for (; s < end; s++) {
				print_stat(s);
			}
		}
	}
}

void oneway_nbi_test(int iters, int nbytes, int alignment)
{GASNET_BEGIN_FUNCTION();
    int i;
    int64_t begin, end;
    stat_struct_t st;
    int pad = (alignment % PAGESZ);

	/* initialize statistics */
	init_stat(&st, nbytes, alignment);
	
	memset(locbuf+pad, 1, nbytes);

	BARRIER();
	
	if (iamsender) {
		/* measure the throughput of nonblocking implicit bulk put */
		begin = TIME();
		for (i = 0; i < iters; i++) {
			gasnet_put_nbi_bulk(peerproc, rembuf, locbuf+pad, nbytes);
		}
		gasnet_wait_syncnbi_puts();
		end = TIME();
	 	update_stat(&st, (end - begin), iters);
	}
	
	BARRIER();
	
	if (iamsender) {
		print_stat(myproc, &st, "put_nbi_bulk throughput", PRINT_THROUGHPUT);
	}	

	/* initialize statistics */
	init_stat(&st, nbytes, alignment);

	if (iamsender) {
		/* measure the throughput of nonblocking implicit bulk get */
		begin = TIME();
		for (i = 0; i < iters; i++) {
	 		gasnet_get_nbi_bulk(locbuf, peerproc, rembuf+pad, nbytes);
		}
		gasnet_wait_syncnbi_gets();
		end = TIME();
	 	update_stat(&st, (end - begin), iters);
	}
	
	BARRIER();
	
	if (iamsender) {
		print_stat(myproc, &st, "get_nbi_bulk throughput", PRINT_THROUGHPUT);
	}	
}

static void		print_args(t_info *info, t_dlst *headdir)
{
	t_node		*tmp;
	t_dlst		*it;

	it = info->headfile.next;
	if (GET(info->opt, OPT_L) || GET(info->opt, OPT_1))
	{
		while (it != &info->headfile)
		{
			tmp = C_NODE(t_node, it);
			if (!GET(info->opt, OPT_A) && tmp->namtyp.d_name[0] == '.')
			{
				it = it->next;
				continue ;
			}
			if (GET(info->opt, OPT_L))
				print_stat(tmp, info);
			else
				print_filename(tmp, info);
			it = it->next;
		}
	}
	else
		test_col_file(info);
	if (!dlst_empty(headdir))
		ft_putchar('\n');
}

void			print_files(t_info *info)
{
	t_node		*tmp;
	t_dlst		*it;

	it = info->headfile.next;
	if (GET(info->opt, OPT_L) && !dlst_empty(&info->headfile))
		ft_printf("total %d\n", info->total);
	if (GET(info->opt, OPT_L) || GET(info->opt, OPT_1))
	{
		while (it != &info->headfile)
		{
			tmp = C_NODE(t_node, it);
			if (!GET(info->opt, OPT_A) && tmp->namtyp.d_name[0] == '.')
			{
				it = it->next;
				continue ;
			}
			if (GET(info->opt, OPT_L))
				print_stat(tmp, info);
			else
				print_filename(tmp, info);
			it = it->next;
		}
	}
	else
		test_col_file(info);
}

int main(void)
{
  read_data();
  printf("\n");
  printf("== 学生数 ==\n");
  printf("%d 人\n", max_student);

  if (max_student <= 0){
    printf("データ数が少なすぎます。\n");
    return (-1);
  }

  printf("\n");
  printf("== 出席番号順の名簿 ==\n");
  sort_by_id();
  print_data();

  printf("\n");
  printf("== 合計点による成績順位表 ==\n");
  sort_by_total();
  print_data();

  printf("\n");
  printf("== 平均点・最高点・最底辺 ==\n");
  print_stat();

  return (0);
}

void merge_stat(const hash_t *day, int type)
{
    hash_t stat;
    hash_create(&stat, 0, top_hash);
    load_stat(&stat, type);

    hash_iter_t *iter;
    top_t *entry;
    const top_t *top;
    for (iter = hash_begin(day); iter; iter = hash_next(iter)) {
        top = (const top_t *)(iter->entry->key);
        entry = hash_get(&stat, top, HASH_KEY_STRING);
        if (entry) {
            entry->count += top->count;
            entry->last = top->last;
        } else {
            if (top->count)
                hash_set(&stat, (char *)top, HASH_KEY_STRING, top);
        }
    }

    top_t **tops = sort_stat(&stat);
    if (tops) {
        print_stat(&stat, tops, type);
        save_stat(&stat, tops, type);
    }
}

void bulk_test(int iters) {GASNET_BEGIN_FUNCTION();
    int i;
    int64_t begin, end;
    stat_struct_t stput;
    int payload;
    
	for (payload = min_payload; payload <= max_payload && payload > 0; payload *= 2) {
		init_stat(&stput, payload);

		BARRIER();
	
		if (iamsender) {
			/* measure the throughput of sending a message */
			begin = TIME();
			for (i = 0; i < iters; i++) {
				gasnet_memset(peerproc, tgtmem, 0xaa, payload);
			}
			end = TIME();
		 	update_stat(&stput, (end - begin), iters);
		}
	
		BARRIER();

		if (iamsender) {
			print_stat(myproc, &stput, "memset throughput", PRINT_THROUGHPUT);
		}	
	
	}

}

void bulk_test_nb(int iters) {GASNET_BEGIN_FUNCTION();
    int i;
    int64_t begin, end;
    stat_struct_t stput;
    gasnet_handle_t *handles;
    int payload;
    
	handles = (gasnet_handle_t *) test_malloc(sizeof(gasnet_handle_t) * iters);

	for (payload = min_payload; payload <= max_payload && payload > 0; payload *= 2) {
		init_stat(&stput, payload);

		BARRIER();
	
		if (iamsender) {
			/* measure the throughput of sending a message */
			begin = TIME();
			for (i = 0; i < iters; i++) {
				handles[i] = gasnet_memset_nb(peerproc, tgtmem, 0x5a, payload);
			}
			gasnet_wait_syncnb_all(handles, iters);
			end = TIME();
		 	update_stat(&stput, (end - begin), iters);
		}
	
		BARRIER();
       
		if (iamsender) {
			print_stat(myproc, &stput, "memset_nb throughput", PRINT_THROUGHPUT);
		}	
	
	}

	test_free(handles);
}

GTA *
st_gta_copy(GTA *g)
{
  Timer temp;

  if (options.time) {
    timer_copy.start();
    if (options.statistics)
      temp.start();
  }

  if (options.statistics) {
    cout << "Copying ";
    print_stat(g);
    cout << "\n";
  }
  
  GTA *result = gtaCopy(g);
  num_copies++;

  if (options.time) {
    timer_copy.stop();
    if (options.statistics) {
      temp.stop();
      cout << "  Time: ";
      temp.print();
    }
  }

  update_largest(result);
  return result;
}

static void
try_df (const char *name, const char *uuid,
        const char *dev, int offset)
{
  struct guestfs_statvfs *stat = NULL;
  guestfs_error_handler_cb old_error_cb;
  void *old_error_data;

  if (verbose)
    fprintf (stderr, "try_df %s %s %d\n", name, dev, offset);

  /* Try mounting and stating the device.  This might reasonably fail,
   * so don't show errors.
   */
  old_error_cb = guestfs_get_error_handler (g, &old_error_data);
  guestfs_set_error_handler (g, NULL, NULL);

  if (guestfs_mount_ro (g, dev, "/") == 0) {
    stat = guestfs_statvfs (g, "/");
    guestfs_umount_all (g);
  }

  guestfs_set_error_handler (g, old_error_cb, old_error_data);

  if (stat) {
    print_stat (name, uuid, dev, offset, stat);
    guestfs_free_statvfs (stat);
  }
}

static int queue_poll_stat_show(void *data, struct seq_file *m)
{
	struct request_queue *q = data;
	int bucket;

	for (bucket = 0; bucket < BLK_MQ_POLL_STATS_BKTS/2; bucket++) {
		seq_printf(m, "read  (%d Bytes): ", 1 << (9+bucket));
		print_stat(m, &q->poll_stat[2*bucket]);
		seq_puts(m, "\n");

		seq_printf(m, "write (%d Bytes): ",  1 << (9+bucket));
		print_stat(m, &q->poll_stat[2*bucket+1]);
		seq_puts(m, "\n");
	}
	return 0;
}

int main (int argc, char ** argv)
{
DIR * dir;
struct dirent * entry;

if (argc < 2) {
    fprintf (stderr, "Too few arguments\n");
    return 1;
}
dir = opendir (argv[1]);

if (dir == NULL) {
    fprintf (stderr, "opendir() error\n");
    return 1;
}
while ((entry = readdir (dir)) != NULL) {
    printf ("%s\t\t", entry->d_name);
if (chdir (argv[1]) == -1) {
    fprintf (stderr, "chdir() error\n");
    return 1;
}
print_stat (entry->d_name);
}
closedir (dir);
return 0;
}