hdf5/examples/credel.c

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <libgen.h> /* basename(3) */
#include <signal.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>   /* struct timespec, nanosleep */
#include <unistd.h> /* getopt, PATH_MAX, ... */

#include "hdf5.h"
#include "nbcompat.h"

#define DATAROWS 1
#define DATACOLS 10
static const hsize_t dims[2] = {DATAROWS, DATACOLS};
static const hsize_t chunk_dims[2] = {1, 1};
static volatile sig_atomic_t unbroken = 1;

typedef struct {
	uint64_t created, deleted;
} stats_pair_t;

typedef struct {
	stats_pair_t datasets, groups;
	uint64_t iterations;
} stats_t;

typedef struct {
	hid_t dataset[4], dataspace, dapl, dcpl, file, group[2];
	char output_file[PATH_MAX];
	char progname[PATH_MAX];
	struct timespec update_interval;
	int verbose;
	bool oneshot;
	bool print_stats;
	bool use_vfd_swmr;
	uint64_t iterations_limit;
	stats_t stats;
} state_t;

#define ALL_HID_INITIALIZER (state_t){					\
	  .dataspace = H5I_INVALID_HID					\
	, .file = H5I_INVALID_HID					\
	, .verbose = 0							\
	, .oneshot = false						\
	, .use_vfd_swmr = true						\
	, .print_stats = false						\
	, .iterations_limit = UINT64_MAX				\
	, .output_file = ""						\
	, .update_interval = (struct timespec){				\
		  .tv_sec = 0						\
		, .tv_nsec = 1000000000UL / 10 /* 1/10 second */}	\
	, .stats = {{0, 0}, {0, 0}}}

static void state_init(state_t *, int, char **);

static void
write_dataset(state_t *s, int didx)
{
	const int ndatasets = __arraycount(s->dataset);
	hid_t ds;
	int32_t data[DATAROWS][DATACOLS];
	herr_t status;
	unsigned int i, j;

	for (i = 0; i < __arraycount(data); i++) {
		for (j = 0; j < __arraycount(data[i]); j++) {
			int k = (didx + j + i) % __arraycount(data[i]);
			data[i][j] = (0 <= k && k < 3) ? 1 : 0;
			if (s->verbose > 1)
				fprintf(stderr, " %" PRId32, data[i][j]);
		}
		if (s->verbose > 1)
			fprintf(stderr, "\n");
	}

	ds = s->dataset[didx % ndatasets];
	status = H5Dwrite(ds, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL,
		H5P_DEFAULT, data);

	if (status < 0)
		errx(EXIT_FAILURE, "H5Dwrite failed");

	if (H5Dflush(ds) < 0)
		errx(EXIT_FAILURE, "H5Dflush failed");
}

static void
usage(const char *progname)
{
	fprintf(stderr, "usage: %s [-u milliseconds]\n"
		"\n"
		"-o: oneshot mode, perform one iteration, wait for a signal, "
		    "then quit.\n"
		"-s: print statistics at end\n"
		"-S: disable VFD SWMR mode\n"
		"-u ms: milliseconds interval between updates to %s.h5\n"
		"-v: verbose mode, mention creation/deletion; -vv: print data\n"
		"\n",
		progname, progname);
	exit(EXIT_FAILURE);
}

static void
print_stats(stats_t *s)
{
	printf("%10" PRIu64 " groups created\n", s->groups.created);
	printf("%10" PRIu64 " groups deleted\n", s->groups.deleted);
	printf("%10" PRIu64 " datasets created\n", s->datasets.created);
	printf("%10" PRIu64 " datasets deleted\n", s->datasets.deleted);
	printf("%10" PRIu64 " iterations\n", s->iterations);
}

static void
state_init(state_t *s, int argc, char **argv)
{
	int ch, i, rc;
	char tfile[PATH_MAX];
	char *end;
	unsigned long millis;
	uintmax_t niters;

	*s = ALL_HID_INITIALIZER;
	strlcpy(tfile, argv[0], sizeof(tfile));
	strlcpy(s->progname, basename(tfile), sizeof(s->progname));
	while ((ch = getopt(argc, argv, "n:ou:sSv")) != -1) {
		switch (ch) {
		case 'n':
			niters = strtoumax(optarg, &end, 0);
			if (niters == UINTMAX_MAX && errno == ERANGE) {
				err(EXIT_FAILURE, "option -%c argument \"%s\"",
				    ch, optarg);
			} else if (*end != '\0') {
				errx(EXIT_FAILURE,
				    "garbage after -%c argument \"%s\"", ch,
				    optarg);
			}
			s->iterations_limit = niters;
			break;
		case 'o':
			s->oneshot = true;
			break;
		case 's':
			s->print_stats = true;
			break;
		case 'S':
			s->use_vfd_swmr = false;
			break;
		case 'u':
			errno = 0;
			millis = strtoul(optarg, &end, 0);
			if (millis == ULONG_MAX && errno == ERANGE) {
				err(EXIT_FAILURE, "option -%c argument \"%s\"",
				    ch, optarg);
			} else if (*end != '\0') {
				errx(EXIT_FAILURE,
				    "garbage after -%c argument \"%s\"", ch,
				    optarg);
			}
			s->update_interval.tv_sec = millis / 1000UL;
			s->update_interval.tv_nsec = (millis * 1000000UL) % 1000000000UL;
			warnx("%lu milliseconds between updates", millis);
			break;
		case 'v':
			s->verbose++;
			break;
		case '?':
		default:
			usage(s->progname);
		}
	}
	argc -= optind;
	argv += optind;

	for (i = 0; i < __arraycount(s->dataset); i++)
		s->dataset[i] = H5I_INVALID_HID;

	for (i = 0; i < __arraycount(s->group); i++)
		s->group[i] = H5I_INVALID_HID;

	rc = snprintf(s->output_file, sizeof(s->output_file), "%s.h5", s->progname);
	if (rc == -1 || rc >= sizeof(s->output_file))
		errx(EXIT_FAILURE, "output filename was truncated");
}

static void
delete_group(state_t *s, const int64_t gidx)
{
	hid_t g;
	const int ngroups = __arraycount(s->group);
	char gname[32];

	assert(0 <= gidx);

	snprintf(gname, sizeof(gname), "/group-%" PRId64, gidx);
	g = s->group[gidx % ngroups];

	if (H5Ldelete(s->file, gname, H5P_DEFAULT) < 0) {
		errx(EXIT_FAILURE, "%s: H5Ldelete(, \"%s\", ) failed",
		    __func__, gname);
	}

	if (H5Gclose(g) < 0)
		errx(EXIT_FAILURE, "H5Gclose failed");

	if (s->verbose > 0)
		fprintf(stderr, "Deleted group %s\n", gname);

	s->group[gidx % ngroups] = H5I_INVALID_HID;
	s->stats.groups.deleted++;
}

static void
create_group(state_t *s, const int64_t gidx)
{
	const int ngroups = __arraycount(s->group);
	hid_t g;
	char gname[32];

	assert(0 <= gidx);
	assert(s->group[gidx % ngroups] == H5I_INVALID_HID);

	snprintf(gname, sizeof(gname), "/group-%" PRId64, gidx);
	g = H5Gcreate(s->file, gname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);

	if (g < 0)
		errx(EXIT_FAILURE, "H5Gcreate failed");

	if (s->verbose > 0)
		fprintf(stderr, "Created group %s\n", gname);
	s->group[gidx % ngroups] = g;
	s->stats.groups.created++;
}

static void
delete_dataset(state_t *s, const int64_t didx)
{
	const int ndatasets = __arraycount(s->dataset);
	char dname[32];
	const int64_t gidx = didx / 2;

	assert(0 <= gidx && 0 <= didx);

	snprintf(dname, sizeof(dname), "/group-%" PRId64 "/dataset-%" PRId64,
		gidx, didx);
	if (H5Ldelete(s->file, dname, H5P_DEFAULT) < 0) {
		errx(EXIT_FAILURE, "%s: H5Ldelete(, \"%s\", ) failed",
		    __func__, dname);
	}

	if (s->verbose > 0)
		fprintf(stderr, "Deleted dataset %s\n", dname);
#if 1
	const hid_t ds = s->dataset[didx % ndatasets];
	if (H5Dclose(ds) < 0)
		errx(EXIT_FAILURE, "H5Dclose failed");
#endif
	s->dataset[didx % ndatasets] = H5I_INVALID_HID;
	s->stats.datasets.deleted++;
}

static void
create_dataset(state_t *s, const int64_t didx)
{
	const int ndatasets = __arraycount(s->dataset);
	char dname[32];
	const int64_t gidx = didx / 2;
	hid_t ds;

	assert(0 <= gidx && 0 <= didx);
	assert(s->dataset[didx % ndatasets] == H5I_INVALID_HID);

	s->dataspace = H5Screate_simple(__arraycount(dims), dims, NULL);

	if (s->dataspace < 0)
		errx(EXIT_FAILURE, "H5Screate_simple failed");

	snprintf(dname, sizeof(dname), "/group-%" PRId64 "/dataset-%" PRId64,
		gidx, didx);
	ds = H5Dcreate2(s->file, dname,
		H5T_STD_I32BE, s->dataspace,
		H5P_DEFAULT, s->dcpl, s->dapl);

	if (H5Sclose(s->dataspace) < 0)
		errx(EXIT_FAILURE, "H5Sclose failed");

	s->dataspace = H5I_INVALID_HID;

	if (ds < 0)
		errx(EXIT_FAILURE, "H5Dcreate(, \"%s\", ) failed", dname);

	if (s->verbose > 0)
		fprintf(stderr, "Created dataset %s\n", dname);
	s->dataset[didx % ndatasets] = ds;
	s->stats.datasets.created++;
}

static void
create_and_write_dataset(state_t *s, const int64_t didx)
{
#if 0
	const int64_t gidx = didx / 2;
	const int ngroups = __arraycount(s->group);
	const hid_t g = s->group[gidx % ngroups];

	if (H5Odisable_mdc_flushes(g) < 0)
		err(EXIT_FAILURE, "H5Odisable_mdc_flushes failed");
#endif

	create_dataset(s, didx);
	write_dataset(s, didx);

#if 0
	if (H5Oenable_mdc_flushes(g) < 0)
		err(EXIT_FAILURE, "H5Oenable_mdc_flushes failed");
#endif
}

static void
handle_signal(int signo)
{
	char msg[] = "Handling signal\n";
	write(STDERR_FILENO, msg, sizeof(msg) - 1);
	unbroken = 0;
}

static void
disestablish_handler(const struct sigaction *osa)
{
	if (sigaction(SIGINT, osa, NULL) == -1)
		err(EXIT_FAILURE, "%s: sigaction", __func__);
}

static void
establish_handler(struct sigaction *osa)
{
	struct sigaction sa;

	memset(&sa, '\0', sizeof(sa));
	sa.sa_handler = handle_signal;
	sigemptyset(&sa.sa_mask);
	if (sigaction(SIGINT, &sa, osa) == -1)
		err(EXIT_FAILURE, "%s: sigaction", __func__);
}

int
main(int argc, char **argv)
{
	hid_t fapl, fcpl;
	struct sigaction osa;
	state_t storage;
	state_t *s = &storage;
	int64_t i;
	H5F_vfd_swmr_config_t config;

	memset(&config, '\0', sizeof(config));

	state_init(s, argc, argv);

	fapl = H5Pcreate(H5P_FILE_ACCESS);
	if (fapl < 0) {
		errx(EXIT_FAILURE, "%s.%d H5Pcreate failed",
		    __func__, __LINE__);
	}

	fcpl = H5Pcreate(H5P_FILE_CREATE);
	if (fcpl < 0) {
		errx(EXIT_FAILURE, "%s.%d H5Pcreate failed",
		    __func__, __LINE__);
	}

	config.version = H5F__CURR_VFD_SWMR_CONFIG_VERSION;
	config.tick_len = 4;
	config.max_lag = 5;
#if 0   /* raw-data flushing is not implemented */
	config.flush_raw_data = true;
#endif
	config.writer = true;
	config.md_pages_reserved = 128;
	strlcpy(config.md_file_path, "./my_md_file",
	    sizeof(config.md_file_path));

	/* Enable page buffering */
	if (H5Pset_page_buffer_size(fapl, 4096, 100, 0) < 0)
		errx(EXIT_FAILURE, "H5Pset_page_buffer_size failed");

	/* Enable VFD SWMR configuration */
	if (s->use_vfd_swmr && H5Pset_vfd_swmr_config(fapl, &config) < 0)
		errx(EXIT_FAILURE, "H5Pset_vfd_swmr_config failed");

	/* Set file space strategy to paged aggregation in fcpl.
	 * Page buffering *requires* this strategy.
	 *
	 * I set the free-space threshold to 1GB so that deleted
	 * datasets are not recycled.
	 */
	if (H5Pset_file_space_strategy(fcpl,
		H5F_FSPACE_STRATEGY_PAGE, false, 1024 * 1024 * 1024) < 0)
		errx(EXIT_FAILURE, "H5Pset_file_space_strategy failed");

	s->file = H5Fcreate(s->output_file, H5F_ACC_TRUNC, fcpl, fapl);

	H5Pclose(fapl);

	if (s->file < 0)
		errx(EXIT_FAILURE, "H5Fcreate failed");

	if ((s->dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) {
		errx(EXIT_FAILURE, "%s.%d: H5Pcreate failed",
		    __func__, __LINE__);
	}
	if ((s->dapl = H5Pcreate(H5P_DATASET_ACCESS)) < 0) {
		errx(EXIT_FAILURE, "%s.%d: H5Pcreate failed",
		    __func__, __LINE__);
	}
	if (H5Pset_chunk(s->dcpl, 2, chunk_dims) < 0)
		errx(EXIT_FAILURE, "H5Pset_chunk failed");
	if (H5Pset_chunk_cache(s->dapl, H5D_CHUNK_CACHE_NSLOTS_DEFAULT, 0,
		H5D_CHUNK_CACHE_W0_DEFAULT) < 0)
		errx(EXIT_FAILURE, "H5Pset_chunk_cache failed");

	establish_handler(&osa);

	for (i = 0; i < 4; i++) {
		s->stats.iterations++;
		if (i % 2 == 0)
			create_group(s, i / 2);
		create_and_write_dataset(s, i);
	}

	for (i = 5; unbroken; i += 2) {
		delete_dataset(s, i - 5);
		delete_dataset(s, i - 4);
		delete_group(s, (i - 4) / 2);
		create_group(s, i / 2);
		create_and_write_dataset(s, i - 1);
		create_and_write_dataset(s, i);
		if (s->oneshot || ++s->stats.iterations >= s->iterations_limit)
			break;
		nanosleep(&s->update_interval, NULL);
	}

	if (s->oneshot) {
		sigset_t mask;
		sigemptyset(&mask);
		H5Fvfd_swmr_end_tick(s->file);
		(void)sigsuspend(&mask);
	}
#if 0
	fprintf(stderr, "Interrupted.  Cleaning up.\n");

	int j;
	for (--i, j = 0; j < 4; j++, --i) {
		if (i % 2 == 1) {
			delete_dataset(s, i - 1);
			delete_dataset(s, i);
			delete_group(s, i / 2);
		}
	}

	for (j = 0; j < 4; j++) {
		assert(s->dataset[j] == H5I_INVALID_HID);
		assert(s->group[j / 2] == H5I_INVALID_HID);
	}
#endif

	if (s->print_stats)
		print_stats(&s->stats);

	if (H5Fclose(s->file) < 0)
		errx(EXIT_FAILURE, "H5Fclose failed");

	if (H5Pclose(s->dapl) < 0)
		errx(EXIT_FAILURE, "H5Pclose failed");

	if (H5Pclose(s->dcpl) < 0)
		errx(EXIT_FAILURE, "H5Pclose failed");

	disestablish_handler(&osa);

	return EXIT_SUCCESS;
}