static int builtin_posix_module_dataset_init (struct hio_module_t *module,
builtin_posix_module_dataset_t *posix_dataset) {
hio_context_t context = hioi_object_context ((hio_object_t) posix_dataset);
int rc;
rc = asprintf (&posix_dataset->base_path, "%s/%s.hio/%s/%lu", module->data_root,
hioi_object_identifier(context), hioi_object_identifier (posix_dataset),
(unsigned long) posix_dataset->base.ds_id);
assert (0 < rc);
/* initialize posix dataset specific data */
for (int i = 0 ; i < HIO_POSIX_MAX_OPEN_FILES ; ++i) {
posix_dataset->files[i].f_bid = -1;
posix_dataset->files[i].f_hndl = NULL;
posix_dataset->files[i].f_fd = -1;
}
/* default to strided output mode */
posix_dataset->ds_fmode = HIO_FILE_MODE_STRIDED;
hioi_config_add (context, &posix_dataset->base.ds_object, &posix_dataset->ds_fmode,
"dataset_file_mode", HIO_CONFIG_TYPE_INT32, &hioi_dataset_file_modes,
"Modes for writing dataset files. Valid values: (0: basic, 1: file_per_node, 2: strided)", 0);
if (HIO_FILE_MODE_STRIDED == posix_dataset->ds_fmode && HIO_SET_ELEMENT_UNIQUE == posix_dataset->base.ds_mode) {
/* strided mode only applies to shared datasets */
posix_dataset->ds_fmode = HIO_FILE_MODE_BASIC;
}
if (HIO_FILE_MODE_BASIC != posix_dataset->ds_fmode) {
posix_dataset->ds_bs = 1ul << 23;
hioi_config_add (context, &posix_dataset->base.ds_object, &posix_dataset->ds_bs,
"dataset_block_size", HIO_CONFIG_TYPE_INT64, NULL,
"Block size to use when writing in optimized mode (default: 8M)", 0);
}
return HIO_SUCCESS;
}
static int builtin_posix_module_dataset_open (struct hio_module_t *module, hio_dataset_t dataset) {
builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) dataset;
builtin_posix_module_t *posix_module = (builtin_posix_module_t *) module;
hio_context_t context = hioi_object_context ((hio_object_t) dataset);
unsigned char *manifest = NULL;
size_t manifest_size = 0;
hio_fs_attr_t *fs_attr;
uint64_t start, stop;
int rc = HIO_SUCCESS;
char *path = NULL;
start = hioi_gettime ();
hioi_log (context, HIO_VERBOSE_DEBUG_MED, "posix:dataset_open: opening dataset %s:%lu mpi: %d flags: 0x%x mode: 0x%x",
hioi_object_identifier (dataset), (unsigned long) dataset->ds_id, hioi_context_using_mpi (context),
dataset->ds_flags, dataset->ds_mode);
rc = builtin_posix_module_dataset_init (module, posix_dataset);
if (HIO_SUCCESS != rc) {
return rc;
}
fs_attr = &posix_dataset->base.ds_fsattr;
rc = hioi_fs_query (context, module->data_root, fs_attr);
if (HIO_SUCCESS != rc) {
hioi_err_push (rc, &context->c_object, "posix: error querying the filesystem");
return rc;
}
if (fs_attr->fs_flags & HIO_FS_SUPPORTS_STRIPING) {
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_scount,
"stripe_count", HIO_CONFIG_TYPE_UINT32, NULL, "Stripe count for all dataset "
"data files", 0);
if (fs_attr->fs_scount > fs_attr->fs_smax_count) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe count %u exceeds the available resources. "
"adjusting to maximum %u", fs_attr->fs_scount, fs_attr->fs_smax_count);
fs_attr->fs_scount = fs_attr->fs_smax_count;
}
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_ssize,
"stripe_size", HIO_CONFIG_TYPE_UINT64, NULL, "Stripe size for all dataset "
"data files", 0);
/* ensure the stripe size is a multiple of the stripe unit */
fs_attr->fs_ssize = fs_attr->fs_sunit * ((fs_attr->fs_ssize + fs_attr->fs_sunit - 1) / fs_attr->fs_sunit);
if (fs_attr->fs_ssize > fs_attr->fs_smax_size) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe size %" PRIu64 " exceeds the maximum %"
PRIu64 ". ", fs_attr->fs_ssize, fs_attr->fs_smax_size);
fs_attr->fs_ssize = fs_attr->fs_smax_size;
}
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_raid_level,
"raid_level", HIO_CONFIG_TYPE_UINT64, NULL, "RAID level for dataset "
"data files. Keep in mind that some filesystems only support 1/2 RAID "
"levels", 0);
if (HIO_FILE_MODE_OPTIMIZED == dataset->ds_fmode) {
fs_attr->fs_scount = 1;
fs_attr->fs_ssize = dataset->ds_bs;
fs_attr->fs_use_group_locking = true;
}
}
do {
if (0 != context->c_rank) {
break;
}
if (dataset->ds_flags & HIO_FLAG_TRUNC) {
/* blow away the existing dataset */
(void) builtin_posix_module_dataset_unlink (module, hioi_object_identifier(dataset),
dataset->ds_id);
/* ensure we take the create path later */
dataset->ds_flags |= HIO_FLAG_CREAT;
}
if (!(dataset->ds_flags & HIO_FLAG_CREAT)) {
/* load manifest. the manifest data will be shared with other processes in hioi_dataset_scatter */
rc = asprintf (&path, "%s/manifest.json.bz2", posix_dataset->base_path);
assert (0 < rc);
if (access (path, F_OK)) {
free (path);
rc = asprintf (&path, "%s/manifest.json", posix_dataset->base_path);
assert (0 < rc);
if (access (path, F_OK)) {
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: could not find top-level manifest");
rc = HIO_ERR_NOT_FOUND;
break;
}
}
rc = hioi_manifest_read (path, &manifest, &manifest_size);
free (path);
} else {
rc = builtin_posix_create_dataset_dirs (posix_module, posix_dataset);
if (HIO_SUCCESS != rc) {
break;
}
rc = hioi_manifest_serialize (dataset, &manifest, &manifest_size, true);
}
} while (0);
/* share dataset information will all processes in the communication domain */
rc = hioi_dataset_scatter (dataset, manifest, manifest_size, rc);
if (HIO_SUCCESS != rc) {
free (posix_dataset->base_path);
return rc;
}
free (manifest);
if (HIO_FILE_MODE_OPTIMIZED == dataset->ds_fmode) {
if (HIO_SET_ELEMENT_UNIQUE == dataset->ds_mode || 2 > context->c_size || NULL == dataset->ds_shared_control) {
posix_dataset->base.ds_fmode = HIO_FILE_MODE_BASIC;
/* NTH: no optimized mode for N->N yet */
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: optimized file mode requested but not supported in this "
"dataset mode. falling back to basic file mode");
}
}
dataset->ds_module = module;
dataset->ds_close = builtin_posix_module_dataset_close;
dataset->ds_element_open = builtin_posix_module_element_open;
dataset->ds_process_reqs = builtin_posix_module_process_reqs;
pthread_mutex_init (&posix_dataset->lock, NULL);
/* record the open time */
gettimeofday (&dataset->ds_otime, NULL);
stop = hioi_gettime ();
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: successfully %s posix dataset %s:%llu on data root %s. "
"open time %lu usec", (dataset->ds_flags & HIO_FLAG_CREAT) ? "created" : "opened", hioi_object_identifier(dataset),
dataset->ds_id, module->data_root, stop - start);
return HIO_SUCCESS;
}
static int builtin_posix_module_dataset_open (struct hio_module_t *module, hio_dataset_t dataset) {
builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) dataset;
builtin_posix_module_t *posix_module = (builtin_posix_module_t *) module;
hio_context_t context = hioi_object_context ((hio_object_t) dataset);
unsigned char *manifest = NULL;
size_t manifest_size = 0;
uint64_t start, stop;
int rc = HIO_SUCCESS;
char *path = NULL;
start = hioi_gettime ();
hioi_log (context, HIO_VERBOSE_DEBUG_MED, "posix:dataset_open: opening dataset %s:%lu mpi: %d flags: 0x%x mode: 0x%x",
hioi_object_identifier (dataset), (unsigned long) dataset->ds_id, hioi_context_using_mpi (context),
dataset->ds_flags, dataset->ds_mode);
rc = builtin_posix_module_dataset_init (module, posix_dataset);
if (HIO_SUCCESS != rc) {
return rc;
}
rc = builtin_posix_module_setup_striping (context, module, dataset);
if (HIO_SUCCESS != rc) {
return rc;
}
if (HIO_FILE_MODE_STRIDED == posix_dataset->ds_fmode) {
hioi_config_add (context, &dataset->ds_object, &posix_dataset->ds_fcount,
"dataset_file_count", HIO_CONFIG_TYPE_UINT64, NULL, "Number of files to use "
"in strided file mode", 0);
} else if (HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode) {
posix_dataset->ds_use_bzip = true;
hioi_config_add (context, &dataset->ds_object, &posix_dataset->ds_use_bzip,
"dataset_use_bzip", HIO_CONFIG_TYPE_BOOL, NULL,
"Use bzip2 compression for dataset manifests", 0);
}
if (dataset->ds_flags & HIO_FLAG_TRUNC) {
/* blow away the existing dataset */
if (0 == context->c_rank) {
(void) builtin_posix_module_dataset_unlink (module, hioi_object_identifier(dataset),
dataset->ds_id);
}
}
if (!(dataset->ds_flags & HIO_FLAG_CREAT)) {
if (0 == context->c_rank) {
/* load manifest. the manifest data will be shared with other processes in hioi_dataset_scatter */
rc = asprintf (&path, "%s/manifest.json", posix_dataset->base_path);
assert (0 < rc);
if (access (path, F_OK)) {
/* this should never happen on a valid dataset */
free (path);
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: could not find top-level manifest %s", path);
rc = HIO_ERR_NOT_FOUND;
} else {
rc = HIO_SUCCESS;
}
}
/* read the manifest if it exists */
if (HIO_SUCCESS == rc) {
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: loading manifest header from %s...", path);
rc = hioi_manifest_read (path, &manifest, &manifest_size);
free (path);
path = NULL;
}
} else if (0 == context->c_rank) {
rc = builtin_posix_create_dataset_dirs (posix_module, posix_dataset);
if (HIO_SUCCESS == rc) {
/* serialize the manifest to send to remote ranks */
rc = hioi_manifest_serialize (dataset, &manifest, &manifest_size, false, false);
}
}
#if HIO_MPI_HAVE(1)
/* share dataset header will all processes in the communication domain */
rc = hioi_dataset_scatter_comm (dataset, context->c_comm, manifest, manifest_size, rc);
#endif
free (manifest);
if (HIO_SUCCESS != rc) {
free (posix_dataset->base_path);
return rc;
}
if (context->c_enable_tracing) {
char *path;
rc = asprintf (&path, "%s/trace/trace.%d", posix_dataset->base_path, context->c_rank);
if (rc > 0) {
posix_dataset->ds_trace_fh = fopen (path, "a");
free (path);
}
builtin_posix_trace (posix_dataset, "trace_begin", 0, 0, 0, 0);
}
#if HIO_MPI_HAVE(3)
if (!(dataset->ds_flags & HIO_FLAG_CREAT) && HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode) {
rc = bultin_posix_scatter_data (posix_dataset);
if (HIO_SUCCESS != rc) {
free (posix_dataset->base_path);
return rc;
}
}
/* if possible set up a shared memory window for this dataset */
POSIX_TRACE_CALL(posix_dataset, hioi_dataset_shared_init (dataset, 1), "shared_init", 0, 0);
if (HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode) {
if (2 > context->c_size || NULL == dataset->ds_shared_control) {
/* no point in using optimized mode in this case */
posix_dataset->ds_fmode = HIO_FILE_MODE_BASIC;
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: optimized file mode requested but not supported in this "
"dataset mode. falling back to basic file mode, path: %s", posix_dataset->base_path);
} else if (HIO_SET_ELEMENT_SHARED == dataset->ds_mode) {
POSIX_TRACE_CALL(posix_dataset, rc = hioi_dataset_generate_map (dataset), "generate_map", 0, 0);
if (HIO_SUCCESS != rc) {
free (posix_dataset->base_path);
return rc;
}
}
}
/* NTH: if requested more code is needed to load an optimized dataset with an older MPI */
#endif /* HIO_MPI_HAVE(3) */
dataset->ds_module = module;
dataset->ds_close = builtin_posix_module_dataset_close;
dataset->ds_element_open = builtin_posix_module_element_open;
dataset->ds_process_reqs = builtin_posix_module_process_reqs;
/* record the open time */
gettimeofday (&dataset->ds_otime, NULL);
stop = hioi_gettime ();
hioi_log (context, HIO_VERBOSE_DEBUG_LOW, "posix:dataset_open: successfully %s posix dataset "
"%s:%" PRIu64 " on data root %s. open time %" PRIu64 " usec",
(dataset->ds_flags & HIO_FLAG_CREAT) ? "created" : "opened", hioi_object_identifier(dataset),
dataset->ds_id, module->data_root, stop - start);
builtin_posix_trace (posix_dataset, "open", 0, 0, start, stop);
return HIO_SUCCESS;
}
static int builtin_posix_module_setup_striping (hio_context_t context, struct hio_module_t *module, hio_dataset_t dataset) {
builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) dataset;
hio_fs_attr_t *fs_attr = &dataset->ds_fsattr;
int rc;
/* query the filesystem for current striping parameters */
rc = hioi_fs_query (context, module->data_root, fs_attr);
if (HIO_SUCCESS != rc) {
hioi_err_push (rc, &context->c_object, "posix: error querying the filesystem");
return rc;
}
/* for now do not use stripe exclusivity in any path */
posix_dataset->my_stripe = 0;
/* set default stripe count */
fs_attr->fs_scount = 1;
posix_dataset->ds_fcount = 1;
if (fs_attr->fs_flags & HIO_FS_SUPPORTS_STRIPING) {
if (HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode) {
/* pick a reasonable default stripe size */
fs_attr->fs_ssize = 1 << 24;
/* use group locking if available as we guarantee stripe exclusivity in optimized mode */
fs_attr->fs_use_group_locking = true;
#if HIO_MPI_HAVE(3)
/* if group locking is not available then each rank should attempt to write to
* a different stripe to maximize the available IO bandwidth */
fs_attr->fs_scount = min(context->c_shared_size, fs_attr->fs_smax_count);
#endif
} else if (HIO_FILE_MODE_STRIDED == posix_dataset->ds_fmode) {
/* pick a reasonable default stripe size */
fs_attr->fs_ssize = posix_dataset->ds_bs;
posix_dataset->ds_fcount = fs_attr->fs_smax_count * 32;
fs_attr->fs_scount = 16;
if (context->c_size < posix_dataset->ds_fcount) {
posix_dataset->ds_fcount = context->c_size;
}
} else if (HIO_SET_ELEMENT_UNIQUE != dataset->ds_mode) {
/* set defaults striping count */
fs_attr->fs_ssize = 1 << 20;
fs_attr->fs_scount = max (1, (unsigned) ((float) fs_attr->fs_smax_count * 0.9));
} else {
fs_attr->fs_ssize = 1 << 20;
}
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_scount,
"stripe_count", HIO_CONFIG_TYPE_UINT32, NULL, "Stripe count for all dataset "
"data files", 0);
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_ssize,
"stripe_size", HIO_CONFIG_TYPE_UINT64, NULL, "Stripe size for all dataset "
"data files", 0);
if (fs_attr->fs_flags & HIO_FS_SUPPORTS_RAID) {
hioi_config_add (context, &dataset->ds_object, &fs_attr->fs_raid_level,
"raid_level", HIO_CONFIG_TYPE_UINT64, NULL, "RAID level for dataset "
"data files. Keep in mind that some filesystems only support 1/2 RAID "
"levels", 0);
}
/* ensure stripe count is sane */
if (fs_attr->fs_scount > fs_attr->fs_smax_count) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe count %u exceeds the available resources. "
"adjusting to maximum %u", fs_attr->fs_scount, fs_attr->fs_smax_count);
fs_attr->fs_scount = fs_attr->fs_smax_count;
}
/* ensure the stripe size is a multiple of the stripe unit */
fs_attr->fs_ssize = fs_attr->fs_sunit * ((fs_attr->fs_ssize + fs_attr->fs_sunit - 1) / fs_attr->fs_sunit);
if (fs_attr->fs_ssize > fs_attr->fs_smax_size) {
hioi_log (context, HIO_VERBOSE_WARN, "posix:dataset_open: requested stripe size %" PRIu64 " exceeds the maximum %"
PRIu64 ". ", fs_attr->fs_ssize, fs_attr->fs_smax_size);
fs_attr->fs_ssize = fs_attr->fs_smax_size;
}
if (HIO_FILE_MODE_OPTIMIZED == posix_dataset->ds_fmode && posix_dataset->ds_bs < fs_attr->fs_ssize) {
posix_dataset->ds_bs = fs_attr->fs_ssize;
}
}
return HIO_SUCCESS;
}
