Пример #1
0
static ssize_t builtin_posix_module_element_write_strided_internal (builtin_posix_module_t *posix_module, hio_element_t element,
                                                                    off_t offset, const void *ptr, size_t count, size_t size,
                                                                    size_t stride) {
  hio_dataset_t dataset = hioi_element_dataset (element);
  size_t bytes_written = 0, ret;
  hio_file_t *file;
  uint64_t stop, start;
  int rc;

  assert (dataset->ds_flags & HIO_FLAG_WRITE);

  if (!(count * size)) {
    return 0;
  }

  if (0 == stride) {
    size *= count;
    count = 1;
  }

  start = hioi_gettime ();

  errno = 0;

  for (size_t i = 0 ; i < count ; ++i) {
    size_t req = size, actual;

    do {
      actual = req;

      rc = builtin_posix_element_translate (posix_module, element, offset, &actual,
                                            &file, false);
      assert (file);
      if (HIO_SUCCESS != rc) {
        break;
      }

      ret = fwrite (ptr, 1, actual, file->f_hndl);
      if (ret > 0) {
        bytes_written += ret;
        file->f_offset += ret;
      }

      if (ret < actual) {
        /* short write */
        break;
      }

      req -= actual;
      offset += actual;
      ptr = (void *) ((intptr_t) ptr + actual);
    } while (req);

    if (HIO_SUCCESS != rc || req) {
      break;
    }

    ptr = (void *) ((intptr_t) ptr + stride);
  }

  if (0 == bytes_written || HIO_SUCCESS != rc) {
    if (0 == bytes_written) {
      rc = hioi_err_errno (errno);
    }

    dataset->ds_status = rc;
    return rc;
  }

  if (offset + bytes_written > element->e_size) {
    element->e_size = offset + bytes_written;
  }

  stop = hioi_gettime ();

  dataset->ds_stat.s_wtime += stop - start;

  if (0 < bytes_written) {
    dataset->ds_stat.s_bwritten += bytes_written;
  }

  hioi_log (hioi_object_context (&element->e_object), HIO_VERBOSE_DEBUG_LOW, "posix: finished write. bytes written: "
            "%lu, time: %llu usec", bytes_written, stop - start);

  return bytes_written;
}
Пример #2
0
static ssize_t builtin_posix_module_element_read_strided_internal (builtin_posix_module_t *posix_module, hio_element_t element,
                                                                   off_t offset, void *ptr, size_t count, size_t size,
                                                                   size_t stride) {
  builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) hioi_element_dataset (element);
  size_t bytes_read = 0, ret;
  hio_file_t *file;
  uint64_t start, stop;
  int rc;

  if (!(count * size)) {
    return 0;
  }

  errno = 0;

  start = hioi_gettime ();

  for (size_t i = 0 ; i < count ; ++i) {
    size_t req = size, actual;

    do {
      actual = req;

      rc = builtin_posix_element_translate (posix_module, element, offset, &actual,
                                            &file, true);
      if (HIO_SUCCESS != rc) {
        break;
      }

      ret = fread (ptr, 1, actual, file->f_hndl);
      if (ret > 0) {
        bytes_read += ret;
        file->f_offset += ret;
      }

      if (ret < actual) {
        /* short read */
        break;
      }

      req -= actual;
      offset += actual;
      ptr = (void *) ((intptr_t) ptr + actual);
    } while (req);

    if (req || HIO_SUCCESS != rc) {
      break;
    }

    ptr = (void *) ((intptr_t) ptr + stride);
  }

  if (0 == bytes_read || HIO_SUCCESS != rc) {
    if (0 == bytes_read) {
      rc = hioi_err_errno (errno);
    }
    return rc;
  }

  stop = hioi_gettime ();
  posix_dataset->base.ds_stat.s_rtime += stop - start;
  posix_dataset->base.ds_stat.s_bread += bytes_read;

  return bytes_read;
}
Пример #3
0
static ssize_t builtin_posix_module_element_read_strided_internal (builtin_posix_module_t *posix_module, hio_element_t element,
                                                                   uint64_t offset, void *ptr, size_t count, size_t size,
                                                                   size_t stride) {
  builtin_posix_module_dataset_t *posix_dataset = (builtin_posix_module_dataset_t *) hioi_element_dataset (element);
  size_t bytes_read = 0, ret;
  hio_file_t *file;
  uint64_t start, stop;
  int rc;

  if (0 == count || 0 == size) {
    return 0;
  }

  errno = 0;

  start = hioi_gettime ();

  for (size_t i = 0 ; i < count ; ++i) {
    size_t req = size, actual;

    do {
      actual = req;

      /* find out where the data lives */
      POSIX_TRACE_CALL(posix_dataset, rc = builtin_posix_element_translate (posix_module, element, offset, &actual,
                                                                            &file, true),
                       "element_translate", offset, req);
      if (HIO_SUCCESS != rc) {
        break;
      }

      POSIX_TRACE_CALL(posix_dataset, ret = hioi_file_read (file, ptr, actual), "file_read", offset, actual);
      if (ret > 0) {
        bytes_read += ret;
      }

      if (ret < actual) {
        /* short read */
        break;
      }

      req -= actual;
      offset += actual;
      ptr = (void *) ((intptr_t) ptr + actual);
    } while (req);

    if (req || HIO_SUCCESS != rc) {
      break;
    }

    ptr = (void *) ((intptr_t) ptr + stride);
  }

  if (0 == bytes_read || HIO_SUCCESS != rc) {
    if (0 == bytes_read && HIO_SUCCESS == rc) {
      rc = hioi_err_errno (errno);
    }

    return rc;
  }

  stop = hioi_gettime ();
  posix_dataset->base.ds_stat.s_rtime += stop - start;
  posix_dataset->base.ds_stat.s_bread += bytes_read;

  return bytes_read;
}