Linting

Author: Omar Marzouk

tensorflow_io/core/filesystems/dfs/dfs_filesystem.cc

@@ -13,39 +13,37 @@ typedef struct DFSRandomAccessFile {
   DAOS_FILE daos_file;
   std::vector<ReadBuffer> buffers;
   daos_size_t file_size;
-  DFSRandomAccessFile(std::string dfs_path, dfs_t* file_system, daos_handle_t eqh,
-                      dfs_obj_t* obj)
+  DFSRandomAccessFile(std::string dfs_path, dfs_t* file_system,
+                      daos_handle_t eqh, dfs_obj_t* obj)
       : dfs_path(std::move(dfs_path)) {
     daos_fs = file_system;
     daos_file.file = obj;
     dfs_get_size(daos_fs, obj, &file_size);
     size_t num_of_buffers;
     size_t buff_size;
 
-    if(char* env_num_of_buffers = std::getenv("TF_IO_DAOS_NUM_OF_BUFFERS")) {
+    if (char* env_num_of_buffers = std::getenv("TF_IO_DAOS_NUM_OF_BUFFERS")) {
       num_of_buffers = atoi(env_num_of_buffers);
-    }
-    else {
+    } else {
       num_of_buffers = NUM_OF_BUFFERS;
     }
 
-    if(char* env_buff_size = std::getenv("TF_IO_DAOS_BUFFER_SIZE")) {
+    if (char* env_buff_size = std::getenv("TF_IO_DAOS_BUFFER_SIZE")) {
       buff_size = GetStorageSize(env_buff_size);
-    }
-    else {
+    } else {
       buff_size = BUFF_SIZE;
     }
     std::cout << buff_size / 1024 / 1024 << std::endl;
     std::cout << num_of_buffers << std::endl;
-    for(size_t i = 0; i < num_of_buffers; i++) {
+    for (size_t i = 0; i < num_of_buffers; i++) {
       buffers.push_back(ReadBuffer(i, eqh, buff_size));
     }
   }
 } DFSRandomAccessFile;
 
 void Cleanup(TF_RandomAccessFile* file) {
   auto dfs_file = static_cast<DFSRandomAccessFile*>(file->plugin_file);
-  for(auto& read_buf: dfs_file->buffers) {
+  for (auto& read_buf : dfs_file->buffers) {
     read_buf.AbortEvent();
   }
   dfs_release(dfs_file->daos_file.file);
@@ -56,21 +54,25 @@ void Cleanup(TF_RandomAccessFile* file) {
 int64_t Read(const TF_RandomAccessFile* file, uint64_t offset, size_t n,
              char* ret, TF_Status* status) {
   auto dfs_file = static_cast<DFSRandomAccessFile*>(file->plugin_file);
-  for(auto& read_buf: dfs_file->buffers) {
-    if(read_buf.CacheHit(offset, n))
-      return read_buf.CopyFromCache(ret, offset, n, dfs_file->file_size, status);
+  for (auto& read_buf : dfs_file->buffers) {
+    if (read_buf.CacheHit(offset, n))
+      return read_buf.CopyFromCache(ret, offset, n, dfs_file->file_size,
+                                    status);
   }
 
   size_t curr_offset = offset + BUFF_SIZE;
-  for(size_t i = 1; i < dfs_file->buffers.size(); i++) {
-    if(curr_offset > dfs_file->file_size) break;
-    dfs_file->buffers[i].ReadAsync(dfs_file->daos_fs, dfs_file->daos_file.file, curr_offset);
+  for (size_t i = 1; i < dfs_file->buffers.size(); i++) {
+    if (curr_offset > dfs_file->file_size) break;
+    dfs_file->buffers[i].ReadAsync(dfs_file->daos_fs, dfs_file->daos_file.file,
+                                   curr_offset);
     curr_offset += BUFF_SIZE;
   }
 
-  dfs_file->buffers[0].ReadSync(dfs_file->daos_fs, dfs_file->daos_file.file, offset);
+  dfs_file->buffers[0].ReadSync(dfs_file->daos_fs, dfs_file->daos_file.file,
+                                offset);
 
-  return dfs_file->buffers[0].CopyFromCache(ret, offset, n, dfs_file->file_size, status);
+  return dfs_file->buffers[0].CopyFromCache(ret, offset, n, dfs_file->file_size,
+                                            status);
 }
 
 }  // namespace tf_random_access_file
@@ -204,9 +206,10 @@ void NewRandomAccessFile(const TF_Filesystem* filesystem, const char* path,
     TF_SetStatus(status, TF_INTERNAL, "Error initializng DAOS API");
     return;
   }
-  auto random_access_file =  new tf_random_access_file::DFSRandomAccessFile(path, daos->daos_fs, daos->mEventQueueHandle, 
-                                                                            obj);
-  random_access_file->buffers[0].ReadAsync(daos->daos_fs, random_access_file->daos_file.file, 0);
+  auto random_access_file = new tf_random_access_file::DFSRandomAccessFile(
+      path, daos->daos_fs, daos->mEventQueueHandle, obj);
+  random_access_file->buffers[0].ReadAsync(
+      daos->daos_fs, random_access_file->daos_file.file, 0);
   file->plugin_file = random_access_file;
   TF_SetStatus(status, TF_OK, "");
 }
@@ -237,7 +240,7 @@ void PathExists(const TF_Filesystem* filesystem, const char* path,
   }
   std::string pool, cont, file;
   rc = daos->Setup(path, pool, cont, file, status);
-  if(rc) return;
+  if (rc) return;
   dfs_obj_t* obj;
   rc = daos->dfsPathExists(file, &obj);
   if (rc) {

tensorflow_io/core/filesystems/dfs/dfs_utils.cc

@@ -17,31 +17,30 @@ std::string GetStorageString(uint64_t size) {
 size_t GetStorageSize(std::string size) {
   char size_char = size.back();
   size_t curr_scale = 1;
-  switch (size_char)
-  {
-  case 'K':
-    size.pop_back();
-    curr_scale *= 1024;
-    return (size_t) atoi(size.c_str()) * curr_scale;
-    break;
-  case 'M':
-    size.pop_back();
-    curr_scale *= 1024 * 1024;
-    return (size_t) atoi(size.c_str()) * curr_scale;
-    break;
-  case 'G':
-    size.pop_back();
-    curr_scale *= 1024 * 1024 * 1024;
-    return (size_t) atoi(size.c_str()) * curr_scale;
-    break;
-  case 'T':
-    size.pop_back();
-    curr_scale *= 1024 * 1024 * 1024;
-    return (size_t) atoi(size.c_str()) * curr_scale * 1024;
-    break;
-  default:
-    return atoi(size.c_str());
-    break;
+  switch (size_char) {
+    case 'K':
+      size.pop_back();
+      curr_scale *= 1024;
+      return (size_t)atoi(size.c_str()) * curr_scale;
+      break;
+    case 'M':
+      size.pop_back();
+      curr_scale *= 1024 * 1024;
+      return (size_t)atoi(size.c_str()) * curr_scale;
+      break;
+    case 'G':
+      size.pop_back();
+      curr_scale *= 1024 * 1024 * 1024;
+      return (size_t)atoi(size.c_str()) * curr_scale;
+      break;
+    case 'T':
+      size.pop_back();
+      curr_scale *= 1024 * 1024 * 1024;
+      return (size_t)atoi(size.c_str()) * curr_scale * 1024;
+      break;
+    default:
+      return atoi(size.c_str());
+      break;
   }
 }
 
@@ -61,8 +60,7 @@ int ParseDFSPath(const std::string& path, std::string& pool_string,
     attr->da_no_prefix = false;
     direct_path = "daos://" + path.substr(pool_start);
     rc = duns_resolve_path(direct_path.c_str(), attr);
-    if(rc)
-      return rc;
+    if (rc) return rc;
   }
   pool_string = attr->da_pool;
   cont_string = attr->da_cont;
@@ -97,9 +95,7 @@ DFS::DFS() {
   is_initialized = false;
 }
 
-DFS::~DFS() { 
-  free(daos_fs); 
-}
+DFS::~DFS() { free(daos_fs); }
 
 DFS* DFS::Load() {
   if (!is_initialized) {
@@ -112,10 +108,10 @@ DFS* DFS::Load() {
   return this;
 }
 
-int DFS::dfsInit() { 
+int DFS::dfsInit() {
   int rc = daos_init();
-  if(rc) return rc;
-  return daos_eq_create(&mEventQueueHandle); 
+  if (rc) return rc;
+  return daos_eq_create(&mEventQueueHandle);
 }
 
 void DFS::dfsCleanup() {
@@ -149,7 +145,7 @@ void DFS::Teardown() {
   int ret;
   do {
     ret = daos_eq_poll(mEventQueueHandle, 1, -1, 1, &(temp_event));
-  } while(ret == 1); 
+  } while (ret == 1);
   daos_eq_destroy(mEventQueueHandle, 0);
   Unmount();
   ClearConnections();
@@ -462,22 +458,23 @@ int DFS::DisconnectContainer(std::string pool_string, std::string cont_string) {
   return rc;
 }
 
-ReadBuffer::ReadBuffer(size_t id, daos_handle_t eqh, size_t size): id(id), buffer_size(size), eqh(eqh) {
-    buffer = new char[size];
-    buffer_offset = 0;
-    event = new daos_event_t;
-    daos_event_init(event, eqh,nullptr);
-    valid = false;
+ReadBuffer::ReadBuffer(size_t id, daos_handle_t eqh, size_t size)
+    : id(id), buffer_size(size), eqh(eqh) {
+  buffer = new char[size];
+  buffer_offset = 0;
+  event = new daos_event_t;
+  daos_event_init(event, eqh, nullptr);
+  valid = false;
 }
 
 ReadBuffer::~ReadBuffer() {
-    if(event != nullptr) {
-      bool event_status;
-      daos_event_test(event, 0, &event_status);
-      daos_event_fini(event);
-    }
-    delete [] buffer;
-    delete event;
+  if (event != nullptr) {
+    bool event_status;
+    daos_event_test(event, 0, &event_status);
+    daos_event_fini(event);
+  }
+  delete[] buffer;
+  delete event;
 }
 
 ReadBuffer::ReadBuffer(ReadBuffer&& read_buffer) {
@@ -492,86 +489,78 @@ ReadBuffer::ReadBuffer(ReadBuffer&& read_buffer) {
   read_buffer.event = nullptr;
 }
 
-bool
-ReadBuffer::CacheHit(const size_t pos, const size_t len) {
-  return pos >= buffer_offset && len <= buffer_size && (pos+len <= buffer_offset + buffer_size); 
+bool ReadBuffer::CacheHit(const size_t pos, const size_t len) {
+  return pos >= buffer_offset && len <= buffer_size &&
+         (pos + len <= buffer_offset + buffer_size);
 }
 
-int
-ReadBuffer::WaitEvent() {
-  if(valid) return 0; 
+int ReadBuffer::WaitEvent() {
+  if (valid) return 0;
   bool event_status;
   daos_event_test(event, -1, &event_status);
-  if(event_status) {
+  if (event_status) {
     valid = true;
     return 0;
   }
   return -1;
 }
 
-int
-ReadBuffer::AbortEvent() {
+int ReadBuffer::AbortEvent() {
   bool event_status = false;
   daos_event_test(event, 0, &event_status);
-  if(!event_status)
+  if (!event_status)
     return daos_event_abort(event);
   else
     return 0;
 }
 
-int
-ReadBuffer::ReadAsync(dfs_t* daos_fs, dfs_obj_t* file, const size_t off) {
+int ReadBuffer::ReadAsync(dfs_t* daos_fs, dfs_obj_t* file, const size_t off) {
   int rc = AbortEvent();
-  if(rc) return rc;
+  if (rc) return rc;
   d_iov_set(&iov, (void*)buffer, buffer_size);
   rsgl.sg_nr = 1;
   rsgl.sg_iovs = &iov;
   valid = false;
   buffer_offset = off;
-  dfs_read(daos_fs, file, &rsgl,
-           buffer_offset, &read_size, event);
+  dfs_read(daos_fs, file, &rsgl, buffer_offset, &read_size, event);
   return 0;
 }
 
-int
-ReadBuffer::ReadSync(dfs_t* daos_fs, dfs_obj_t* file, const size_t off) {
+int ReadBuffer::ReadSync(dfs_t* daos_fs, dfs_obj_t* file, const size_t off) {
   int rc = AbortEvent();
-  if(rc) return rc;
+  if (rc) return rc;
   d_iov_set(&iov, (void*)buffer, buffer_size);
   rsgl.sg_nr = 1;
   rsgl.sg_iovs = &iov;
   valid = false;
   buffer_offset = off;
-  rc =  dfs_read(daos_fs, file, &rsgl,
-                 off, &read_size, NULL);
+  rc = dfs_read(daos_fs, file, &rsgl, off, &read_size, NULL);
   valid = true;
   return rc;
 }
 
-int
-ReadBuffer::CopyData(char* ret, const size_t off, const size_t n) {
+int ReadBuffer::CopyData(char* ret, const size_t off, const size_t n) {
   int rc = WaitEvent();
-  if(rc) return rc;
-  memcpy(ret, buffer + (off - buffer_offset), n); 
+  if (rc) return rc;
+  memcpy(ret, buffer + (off - buffer_offset), n);
   return 0;
 }
 
-int
-ReadBuffer::CopyFromCache(char* ret, const size_t off, const size_t n, const daos_size_t file_size, TF_Status* status){
-    size_t read_size;
-    read_size = off + n > file_size? file_size - off : n;
-    int rc = CopyData(ret, off, read_size);
-    if (rc) {
-      TF_SetStatus(status, TF_INTERNAL, "");
-      return 0;
-    }
-
-    if (off + n > file_size) {
-      TF_SetStatus(status, TF_OUT_OF_RANGE, "");
-      return read_size;
-    }
+int ReadBuffer::CopyFromCache(char* ret, const size_t off, const size_t n,
+                              const daos_size_t file_size, TF_Status* status) {
+  size_t read_size;
+  read_size = off + n > file_size ? file_size - off : n;
+  int rc = CopyData(ret, off, read_size);
+  if (rc) {
+    TF_SetStatus(status, TF_INTERNAL, "");
+    return 0;
+  }
 
-    TF_SetStatus(status, TF_OK, "");
+  if (off + n > file_size) {
+    TF_SetStatus(status, TF_OUT_OF_RANGE, "");
     return read_size;
-}
+  }
 
+  TF_SetStatus(status, TF_OK, "");
+  return read_size;
+}