rocFile: Use platform-independent hoff_t

cmake/AISInstall.cmake

@@ -36,6 +36,12 @@ if(BUILD_ROCFILE OR BUILD_HIPFILE)
         )
     endif()
 
+    # Always install the hipfile-types.h file
+    rocm_install(
+        FILES ${CMAKE_SOURCE_DIR}/shared/hipfile-types.h
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    )
+
     # rocm_package_add_dependencies() line should go here
     # when we have dependencies
 

hipfile/include/hipfile.h

@@ -14,6 +14,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#include <hipfile-types.h>
+
 #if defined(__GNUC__)
 #define HIPFILE_API __attribute__((visibility("default")))
 #else
@@ -85,20 +87,6 @@ extern "C" {
  */
 #define HIPFILE_VERSION_PATCH 0
 
-// ***********************************************************************
-//  PLATFORM-INDEPENDENT TYPES
-// ***********************************************************************
-
-/*!
- * @brief Platform-independent offset type
- * @ingroup core
- */
-#ifndef _WIN32
-typedef off_t hoff_t;
-#else
-typedef __int64 hoff_t;
-#endif
-
 // ***********************************************************************
 //  ERROR HANDLING
 // ***********************************************************************

rocfile/include/rocfile.h

@@ -14,6 +14,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#include <hipfile-types.h>
+
 #if defined(__GNUC__)
 #define ROCFILE_API __attribute__((visibility("default")))
 #else
@@ -405,15 +407,15 @@ typedef struct rocFileFSOps {
     /*!
      * Get the assigned priority of a RDMA device. If -1, there is no preference.
      */
-    int (*getRDMADevicePriority)(void *handle, char *, size_t, off_t, struct sockaddr *hostaddr);
+    int (*getRDMADevicePriority)(void *handle, char *, size_t, hoff_t, struct sockaddr *hostaddr);
     /*!
      * Read from the remote filesystem. If NULL, use the Linux VFS.
      */
-    ssize_t (*read)(void *handle, char *, size_t, off_t, rocFileRDMAInfo_t *);
+    ssize_t (*read)(void *handle, char *, size_t, hoff_t, rocFileRDMAInfo_t *);
     /*!
      * Write to the remote filesystem. If NULL, use the Linux VFS.
      */
-    ssize_t (*write)(void *handle, const char *, size_t, off_t, rocFileRDMAInfo_t *);
+    ssize_t (*write)(void *handle, const char *, size_t, hoff_t, rocFileRDMAInfo_t *);
 } rocFileFSOps_t;
 
 /*!
@@ -521,8 +523,8 @@ rocFileError_t rocFileBufDeregister(const void *buffer_base);
  * @return else:    Negative value of the related rocFileOpError_t
  */
 ROCFILE_API
-ssize_t rocFileRead(rocFileHandle_t fh, void *buffer_base, size_t size, off_t file_offset,
-                    off_t buffer_offset);
+ssize_t rocFileRead(rocFileHandle_t fh, void *buffer_base, size_t size, hoff_t file_offset,
+                    hoff_t buffer_offset);
 
 /*!
  * @brief Synchronously write data from a GPU buffer to a file
@@ -539,8 +541,8 @@ ssize_t rocFileRead(rocFileHandle_t fh, void *buffer_base, size_t size, off_t fi
  * @return else:    Negative value of the related rocFileOpError_t
  */
 ROCFILE_API
-ssize_t rocFileWrite(rocFileHandle_t fh, const void *buffer_base, size_t size, off_t file_offset,
-                     off_t buffer_offset);
+ssize_t rocFileWrite(rocFileHandle_t fh, const void *buffer_base, size_t size, hoff_t file_offset,
+                     hoff_t buffer_offset);
 
 // ***********************************************************************
 //  GPU IO DRIVER API
@@ -832,8 +834,8 @@ rocFileError_t rocFileBatchIODestroy(rocFileBatchHandle_t batch_idp);
  * @return A rocFile error
  */
 ROCFILE_API
-rocFileError_t rocFileReadAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, off_t *file_offset_p,
-                                off_t *buffer_offset_p, ssize_t *bytes_read_p, hipStream_t stream);
+rocFileError_t rocFileReadAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, hoff_t *file_offset_p,
+                                hoff_t *buffer_offset_p, ssize_t *bytes_read_p, hipStream_t stream);
 
 /*!
  * @brief Perform an asynchronous write to a stream
@@ -851,8 +853,8 @@ rocFileError_t rocFileReadAsync(rocFileHandle_t fh, void *buffer_base, size_t *s
  * @return A rocFile error
  */
 ROCFILE_API
-rocFileError_t rocFileWriteAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, off_t *file_offset_p,
-                                 off_t *buffer_offset_p, ssize_t *bytes_written_p, hipStream_t stream);
+rocFileError_t rocFileWriteAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, hoff_t *file_offset_p,
+                                 hoff_t *buffer_offset_p, ssize_t *bytes_written_p, hipStream_t stream);
 
 /*!
  * @brief Register a stream to be used by for asynchronous GPU IO

rocfile/src/async.cpp

@@ -78,16 +78,16 @@ AsyncMonitor::completion_thread()
 }
 
 AsyncOp::AsyncOp(IoType _io_type, std::shared_ptr<IFile> _file, std::shared_ptr<IBuffer> _buffer,
-                 std::shared_ptr<IStream> _stream, size_t *_size, off_t *_file_offset, off_t *_buffer_offset,
-                 ssize_t *_bytes_transferred)
+                 std::shared_ptr<IStream> _stream, size_t *_size, hoff_t *_file_offset,
+                 hoff_t *_buffer_offset, ssize_t *_bytes_transferred)
     : io_type{_io_type}, file{_file}, buffer{_buffer}, stream{_stream},
 
       size{stream->fixedIOSize() ? std::variant<size_t, size_t *>{*_size}
                                  : std::variant<size_t, size_t *>{_size}},
-      file_offset{stream->fixedFileOffset() ? std::variant<const off_t, off_t *>{*_file_offset}
-                                            : std::variant<const off_t, off_t *>{_file_offset}},
-      buffer_offset{stream->fixedBufferOffset() ? std::variant<const off_t, off_t *>{*_buffer_offset}
-                                                : std::variant<const off_t, off_t *>{_buffer_offset}},
+      file_offset{stream->fixedFileOffset() ? std::variant<const hoff_t, hoff_t *>{*_file_offset}
+                                            : std::variant<const hoff_t, hoff_t *>{_file_offset}},
+      buffer_offset{stream->fixedBufferOffset() ? std::variant<const hoff_t, hoff_t *>{*_buffer_offset}
+                                                : std::variant<const hoff_t, hoff_t *>{_buffer_offset}},
       bytes_transferred{_bytes_transferred}
 {
 }

rocfile/src/async.h

@@ -22,14 +22,14 @@ namespace rocFile {
 
 class AsyncOp {
 public:
-    const IoType                       io_type;
-    std::shared_ptr<IFile>             file;
-    std::shared_ptr<IBuffer>           buffer;
-    std::shared_ptr<IStream>           stream;
-    std::variant<size_t, size_t *>     size;
-    std::variant<const off_t, off_t *> file_offset;
-    std::variant<const off_t, off_t *> buffer_offset;
-    ssize_t *const                     bytes_transferred;
+    const IoType                         io_type;
+    std::shared_ptr<IFile>               file;
+    std::shared_ptr<IBuffer>             buffer;
+    std::shared_ptr<IStream>             stream;
+    std::variant<size_t, size_t *>       size;
+    std::variant<const hoff_t, hoff_t *> file_offset;
+    std::variant<const hoff_t, hoff_t *> buffer_offset;
+    ssize_t *const                       bytes_transferred;
 
     AsyncOp(const AsyncOp &)            = delete;
     AsyncOp &operator=(const AsyncOp &) = delete;
@@ -38,7 +38,7 @@ class AsyncOp {
     virtual ~AsyncOp();
 
     AsyncOp(IoType ioType, std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer,
-            std::shared_ptr<IStream> stream, size_t *size, off_t *file_offset, off_t *buffer_offset,
+            std::shared_ptr<IStream> stream, size_t *size, hoff_t *file_offset, hoff_t *buffer_offset,
             ssize_t *bytes_transferred);
 };
 

rocfile/src/backend.h

@@ -40,7 +40,7 @@ struct Backend {
     /// @param buffer_offset  Offset from the start of the buffer
     /// @return
     virtual int score(std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size,
-                      off_t file_offset, off_t buffer_offset) const = 0;
+                      hoff_t file_offset, hoff_t buffer_offset) const = 0;
 
     /// @brief Perform a read or write operation
     ///
@@ -55,7 +55,7 @@ struct Backend {
     ///
     /// @throws Hip::RuntimeError Sys::RuntimeError
     virtual ssize_t io(IoType type, std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size,
-                       off_t file_offset, off_t buffer_offset) = 0;
+                       hoff_t file_offset, hoff_t buffer_offset) = 0;
 };
 
 }

rocfile/src/backend/asyncop-fallback.cpp

@@ -25,7 +25,7 @@ hipHostDeleter(void *buffer)
 
 AsyncOpFallback::AsyncOpFallback(IoType _io_type, std::shared_ptr<IFile> _file,
                                  std::shared_ptr<IBuffer> _buffer, std::shared_ptr<IStream> _stream,
-                                 size_t *_size, off_t *_file_offset, off_t *_buffer_offset,
+                                 size_t *_size, hoff_t *_file_offset, hoff_t *_buffer_offset,
                                  ssize_t *_bytes_transferred)
     : AsyncOp{_io_type, _file, _buffer, _stream, _size, _file_offset, _buffer_offset, _bytes_transferred},
       bytes_transferred_internal{0}, gpu_buffer{buffer->getBuffer()}, bounce_buffer_dev_ptr{nullptr},

rocfile/src/backend/asyncop-fallback.h

@@ -18,7 +18,7 @@ struct AsyncOpFallback : AsyncOp {
 
 public:
     AsyncOpFallback(IoType ioType, std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer,
-                    std::shared_ptr<IStream> stream, size_t *size, off_t *fileOffset, off_t *bufferOffset,
+                    std::shared_ptr<IStream> stream, size_t *size, hoff_t *fileOffset, hoff_t *bufferOffset,
                     ssize_t *bytesTransferred);
 
     void *bounceBufferHostPtr();

rocfile/src/backend/fallback.cpp

@@ -19,8 +19,8 @@ using std::unique_ptr;
 static const size_t DefaultChunkSize = 16 * 1024 * 1024;
 
 int
-Fallback::score(std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size, off_t file_offset,
-                off_t buffer_offset) const
+Fallback::score(std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size, hoff_t file_offset,
+                hoff_t buffer_offset) const
 {
     (void)buffer_offset;
     (void)file;
@@ -31,14 +31,14 @@ Fallback::score(std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, si
 
 ssize_t
 Fallback::io(IoType type, std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size,
-             off_t file_offset, off_t buffer_offset)
+             hoff_t file_offset, hoff_t buffer_offset)
 {
     return io(type, file, buffer, size, file_offset, buffer_offset, DefaultChunkSize);
 }
 
 ssize_t
 Fallback::io(IoType io_type, shared_ptr<IFile> file, shared_ptr<IBuffer> buffer, size_t size,
-             off_t file_offset, off_t buffer_offset, size_t chunk_size)
+             hoff_t file_offset, hoff_t buffer_offset, size_t chunk_size)
 {
     size = min(size, rocFile::MAX_RW_COUNT);
 

rocfile/src/backend/fallback.h

@@ -14,17 +14,18 @@ namespace rocFile {
 struct Fallback : public Backend {
     virtual ~Fallback() override = default;
 
-    int score(std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size, off_t file_offset,
-              off_t buffer_offset) const override;
+    int score(std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size, hoff_t file_offset,
+              hoff_t buffer_offset) const override;
 
     ssize_t io(IoType type, std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size,
-               off_t file_offset, off_t buffer_offset) override;
+               hoff_t file_offset, hoff_t buffer_offset) override;
 
     // Once we can import gtest.h and make test suites or test friends everything
     // below here should be made protected.
     // protected:
 
     ssize_t io(IoType type, std::shared_ptr<IFile> file, std::shared_ptr<IBuffer> buffer, size_t size,
-               off_t file_offset, off_t buffer_offset, size_t chunk_size);
+               hoff_t file_offset, hoff_t buffer_offset, size_t chunk_size);
 };
+
 }

rocfile/src/rocfile-private.h

@@ -18,4 +18,4 @@ ROCFILE_API
 void rocFileEnsureDriverInitPrivate();
 
 ssize_t rocFileIo(rocFile::IoType type, rocFileHandle_t fh, const void *buffer_base, size_t size,
-                  off_t file_offset, off_t buffer_offset);
+                  hoff_t file_offset, hoff_t buffer_offset);

rocfile/src/rocfile.cpp

@@ -225,8 +225,8 @@ catch (...) {
 }
 
 ssize_t
-rocFileIo(IoType type, rocFileHandle_t fh, const void *buffer_base, size_t size, off_t file_offset,
-          off_t buffer_offset)
+rocFileIo(IoType type, rocFileHandle_t fh, const void *buffer_base, size_t size, hoff_t file_offset,
+          hoff_t buffer_offset)
 try {
     HIPFILE_WARN_NO_EXIT_DTOR_OFF
     static const auto backends{Context<DriverState>::get()->getBackends()};
@@ -282,13 +282,14 @@ catch (...) {
 }
 
 ssize_t
-rocFileRead(rocFileHandle_t fh, void *buffer_base, size_t size, off_t file_offset, off_t buffer_offset)
+rocFileRead(rocFileHandle_t fh, void *buffer_base, size_t size, hoff_t file_offset, hoff_t buffer_offset)
 {
     return rocFileIo(IoType::Read, fh, buffer_base, size, file_offset, buffer_offset);
 }
 
 ssize_t
-rocFileWrite(rocFileHandle_t fh, const void *buffer_base, size_t size, off_t file_offset, off_t buffer_offset)
+rocFileWrite(rocFileHandle_t fh, const void *buffer_base, size_t size, hoff_t file_offset,
+             hoff_t buffer_offset)
 {
     return rocFileIo(IoType::Write, fh, buffer_base, size, file_offset, buffer_offset);
 }
@@ -458,8 +459,8 @@ catch (...) {
 }
 
 rocFileError_t
-rocFileReadAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, off_t *file_offset_p,
-                 off_t *buffer_offset_p, ssize_t *bytes_read_p, hipStream_t stream)
+rocFileReadAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, hoff_t *file_offset_p,
+                 hoff_t *buffer_offset_p, ssize_t *bytes_read_p, hipStream_t stream)
 try {
     if (Context<DriverState>::get()->getRefCount() == 0) {
         return {rocFileDriverNotInitialized, hipSuccess};
@@ -480,8 +481,8 @@ catch (...) {
 }
 
 rocFileError_t
-rocFileWriteAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, off_t *file_offset_p,
-                  off_t *buffer_offset_p, ssize_t *bytes_written_p, hipStream_t stream)
+rocFileWriteAsync(rocFileHandle_t fh, void *buffer_base, size_t *size_p, hoff_t *file_offset_p,
+                  hoff_t *buffer_offset_p, ssize_t *bytes_written_p, hipStream_t stream)
 try {
     if (Context<DriverState>::get()->getRefCount() == 0) {
         return {rocFileDriverNotInitialized, hipSuccess};