int main()
{
int a, b, min, max;
printf("Enter 2 numbers: ");
if(scanf("%d%d", &a, &b) != 2) { printf("Invalid input.\n"); return 1; }
printf("Minimum is %d\n", get_min(a,b));
get_minmax(a, b, &min, &max);
printf("Min: %d\nMax: %d\n", min, max);
return 0;
}
/*
* Function: run_test
* Purpose: Inner loop call to actually run the I/O test.
* Return: Nothing
* Programmer: Bill Wendling, 18. December 2001
* Modifications:
*/
static int
run_test(iotype iot, parameters parms, struct options *opts)
{
results res;
register int i, ret_value = SUCCESS;
off_t raw_size;
minmax *write_sys_mm_table=NULL;
minmax *write_mm_table=NULL;
minmax *write_gross_mm_table=NULL;
minmax *write_raw_mm_table=NULL;
minmax *read_sys_mm_table=NULL;
minmax *read_mm_table=NULL;
minmax *read_gross_mm_table=NULL;
minmax *read_raw_mm_table=NULL;
minmax write_sys_mm = {0.0F, 0.0F, 0.0F, 0};
minmax write_mm = {0.0F, 0.0F, 0.0F, 0};
minmax write_gross_mm = {0.0F, 0.0F, 0.0F, 0};
minmax write_raw_mm = {0.0F, 0.0F, 0.0F, 0};
minmax read_sys_mm = {0.0F, 0.0F, 0.0F, 0};
minmax read_mm = {0.0F, 0.0F, 0.0F, 0};
minmax read_gross_mm = {0.0F, 0.0F, 0.0F, 0};
minmax read_raw_mm = {0.0F, 0.0F, 0.0F, 0};
raw_size = (off_t)parms.num_bytes;
parms.io_type = iot;
print_indent(2);
output_report("IO API = ");
switch (iot) {
case POSIXIO:
output_report("POSIX\n");
break;
case HDF5:
output_report("HDF5\n");
break;
default:
/* unknown request */
HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
HDassert(0 && "Unknown IO tpe");
break;
}
/* allocate space for tables minmax and that it is sufficient */
/* to initialize all elements to zeros by calloc. */
write_sys_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
write_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
write_gross_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
write_raw_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
if (!parms.h5_write_only) {
read_sys_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
read_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
read_gross_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
read_raw_mm_table = (minmax *)calloc((size_t)parms.num_iters , sizeof(minmax));
}
/* Do IO iteration times, collecting statistics each time */
for (i = 0; i < parms.num_iters; ++i) {
double t;
do_sio(parms, &res);
/* gather all of the "sys write" times */
t = get_time(res.timers, HDF5_MPI_WRITE);
get_minmax(&write_sys_mm, t);
write_sys_mm_table[i] = write_sys_mm;
/* gather all of the "write" times */
t = get_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS);
get_minmax(&write_mm, t);
write_mm_table[i] = write_mm;
/* gather all of the "write" times from open to close */
t = get_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS);
get_minmax(&write_gross_mm, t);
write_gross_mm_table[i] = write_gross_mm;
/* gather all of the raw "write" times */
t = get_time(res.timers, HDF5_RAW_WRITE_FIXED_DIMS);
get_minmax(&write_raw_mm, t);
write_raw_mm_table[i] = write_raw_mm;
if (!parms.h5_write_only) {
/* gather all of the "mpi read" times */
t = get_time(res.timers, HDF5_MPI_READ);
get_minmax(&read_sys_mm, t);
read_sys_mm_table[i] = read_sys_mm;
/* gather all of the "read" times */
t = get_time(res.timers, HDF5_FINE_READ_FIXED_DIMS);
get_minmax(&read_mm, t);
read_mm_table[i] = read_mm;
/* gather all of the "read" times from open to close */
t = get_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS);
get_minmax(&read_gross_mm, t);
read_gross_mm_table[i] = read_gross_mm;
/* gather all of the raw "read" times */
t = get_time(res.timers, HDF5_RAW_READ_FIXED_DIMS);
get_minmax(&read_raw_mm, t);
read_raw_mm_table[i] = read_gross_mm;
}
io_time_destroy(res.timers);
}
/*
* Show various statistics
*/
/* Write statistics */
/* Print the raw data throughput if desired */
if (opts->print_raw) {
/* accumulate and output the max, min, and average "raw write" times */
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("Raw Data Write details:\n");
output_all_info(write_raw_mm_table, parms.num_iters, 4);
}
output_results(opts,"Raw Data Write",write_raw_mm_table,parms.num_iters,raw_size);
} /* end if */
/* show sys write statics */
#if 0
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("MPI Write details:\n");
output_all_info(write_sys_mm_table, parms.num_iters, 4);
}
#endif
/* We don't currently output the MPI write results */
/* accumulate and output the max, min, and average "write" times */
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("Write details:\n");
output_all_info(write_mm_table, parms.num_iters, 4);
}
output_results(opts,"Write",write_mm_table,parms.num_iters,raw_size);
/* accumulate and output the max, min, and average "gross write" times */
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("Write Open-Close details:\n");
output_all_info(write_gross_mm_table, parms.num_iters, 4);
}
output_results(opts,"Write Open-Close",write_gross_mm_table,parms.num_iters,raw_size);
if (!parms.h5_write_only) {
/* Read statistics */
/* Print the raw data throughput if desired */
if (opts->print_raw) {
/* accumulate and output the max, min, and average "raw read" times */
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("Raw Data Read details:\n");
output_all_info(read_raw_mm_table, parms.num_iters, 4);
}
output_results(opts, "Raw Data Read", read_raw_mm_table,
parms.num_iters, raw_size);
} /* end if */
/* show mpi read statics */
#if 0
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("MPI Read details:\n");
output_all_info(read_sys_mm_table, parms.num_iters, 4);
}
#endif
/* We don't currently output the MPI read results */
/* accumulate and output the max, min, and average "read" times */
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("Read details:\n");
output_all_info(read_mm_table, parms.num_iters, 4);
}
output_results(opts, "Read", read_mm_table, parms.num_iters, raw_size);
/* accumulate and output the max, min, and average "gross read" times */
if (sio_debug_level >= 3) {
/* output all of the times for all iterations */
print_indent(3);
output_report("Read Open-Close details:\n");
output_all_info(read_gross_mm_table, parms.num_iters, 4);
}
output_results(opts, "Read Open-Close", read_gross_mm_table,
parms.num_iters, raw_size);
}
/* clean up our mess */
free(write_sys_mm_table);
free(write_mm_table);
free(write_gross_mm_table);
free(write_raw_mm_table);
if (!parms.h5_write_only) {
free(read_sys_mm_table);
free(read_mm_table);
free(read_gross_mm_table);
free(read_raw_mm_table);
}
return ret_value;
}
static void itm_move(WINDOW *src_wd, int src_object, int old_x, int old_y)
{
int x = old_x, y = old_y;
WINDOW *cur_wd = src_wd, *new_wd;
int cur_object = src_object, new_object;
int clip[4];
int ox, oy, kstate, *list, n, nv, i;
boolean cur_state = TRUE, new_state, mreleased;
ICND *icnlist;
if (itm_type(src_wd, src_object) == ITM_PREVDIR)
{
wait_button();
return;
}
if ((itm_list(src_wd, &n, &list) == FALSE) || (n == 0))
return;
for (i = 0; i < n; i++)
{
if (itm_type(src_wd, list[i]) == ITM_PREVDIR)
itm_select(src_wd, list[i], 2, TRUE);
}
free(list);
if (itm_xlist(src_wd, &n, &nv, &list, &icnlist, old_x, old_y) == FALSE)
return;
get_minmax(icnlist, nv, clip);
wind_update(BEG_MCTRL);
graf_mouse(FLAT_HAND, NULL);
draw_icns(icnlist, nv, x, y, clip);
do
{
ox = x;
oy = y;
mreleased = xe_mouse_event(0, &x, &y, &kstate);
if ((x != ox) || (y != oy))
{
draw_icns(icnlist, nv, ox, oy, clip);
find_newobj(x, y, &new_wd, &new_object, &new_state);
if ((cur_wd != new_wd) || (cur_object != new_object))
{
if ((cur_state == FALSE) && (cur_object >= 0))
select_object(cur_wd, cur_object, 2);
cur_wd = new_wd;
cur_object = new_object;
cur_state = new_state;
if ((cur_object >= 0) && (cur_state == FALSE))
select_object(cur_wd, cur_object, 3);
}
if (mreleased == FALSE)
draw_icns(icnlist, nv, x, y, clip);
}
else if (mreleased == TRUE)
draw_icns(icnlist, nv, x, y, clip);
}
while (mreleased == FALSE);
graf_mouse(ARROW, NULL);
wind_update(END_MCTRL);
if ((cur_state == FALSE) && (cur_object >= 0))
select_object(cur_wd, cur_object, 2);
if ((cur_wd != src_wd) || (cur_object != src_object))
{
if (cur_wd != NULL)
{
int cur_type = xw_type(cur_wd);
if ((cur_type == DIR_WIND) || (cur_type == DESK_WIND))
{
/* Test if destination window is the desktop and if the
destination object is -1 (no object). If this is true,
clip the mouse coordinates. */
if ((xw_type(cur_wd) == DESK_WIND) && (cur_object == -1) && (xw_type(src_wd) == DESK_WIND))
clip_coords(clip, x, y, &x, &y);
itm_copy(src_wd, n, list, cur_wd, cur_object, kstate, icnlist, x, y);
}
else
alert_printf(1, MILLCOPY);
}
else
#if _MINT_
if (mint)
itm_drop(src_wd, n, list, kstate, icnlist, x, y); /* HR 050203 drag & drop */
else
#endif
alert_printf(1, MILLCOPY);
}
free(list);
free(icnlist);
}
