SWDEV-470698 - fix formatting, add format check workflow (#657)

projects/clr/rocclr/platform/vmheap.cpp

@@ -67,8 +67,8 @@ bool VmHeap::CommitMemory(void* addr, size_t size) {
   Memory* phys_mem_obj = MemObjMap::FindMemObj(ptr, &offset);
 
   // Map the physical memory to a virtual address
-  Command* cmd = new VirtualMapCommand(
-    GetVmQueue(), Command::EventWaitList{}, addr, padded_size, phys_mem_obj);
+  Command* cmd = new VirtualMapCommand(GetVmQueue(), Command::EventWaitList{}, addr, padded_size,
+                                       phys_mem_obj);
   cmd->enqueue();
   cmd->awaitCompletion();
   cmd->release();
@@ -86,8 +86,7 @@ bool VmHeap::UncommitMemory(void* addr, size_t size) {
   Memory* phys_mem_obj = vaddr_sub_obj->getUserData().phys_mem_obj;
 
   // Unmap the physical memory from a virtual address
-  Command* cmd = new VirtualMapCommand(
-    GetVmQueue(), Command::EventWaitList{}, addr, size, nullptr);
+  Command* cmd = new VirtualMapCommand(GetVmQueue(), Command::EventWaitList{}, addr, size, nullptr);
   cmd->enqueue();
   cmd->awaitCompletion();
   cmd->release();
@@ -98,11 +97,11 @@ bool VmHeap::UncommitMemory(void* addr, size_t size) {
 
 // ================================================================================================
 VmHeap::VmHeap(Device* device, size_t va_size, size_t chunk_size, GetQueueFunc get_queue)
-  : block_alignment_(kMinBlockAlignment)
-  , chunk_size_(chunk_size)
-  , lock_(true)
-  , device_(device)
-  , get_vm_queue_(get_queue) {
+    : block_alignment_(kMinBlockAlignment),
+      chunk_size_(chunk_size),
+      lock_(true),
+      device_(device),
+      get_vm_queue_(get_queue) {
   va_size_ = alignUp(va_size, chunk_size);
   free_size_ = va_size_;
 }
@@ -113,7 +112,7 @@ VmHeap::~VmHeap() {
     ScopedLock k(lock_);
 
     // Release all heap blocks
-    HeapBlock* walk, * next;
+    HeapBlock *walk, *next;
     walk = busy_list_;
     while (walk) {
       next = walk->next_;
@@ -168,7 +167,7 @@ bool VmHeap::MapPhysMemory(size_t offset, size_t size) {
         mapped_size_ += chunk_size_;
         if (mapped_size_ > max_mapped_size_) {
           ClPrint(LOG_INFO, LOG_MEM_POOL, "VM heap grows in physical alloc to %d GB\n",
-            static_cast<int>(mapped_size_ / Gi));
+                  static_cast<int>(mapped_size_ / Gi));
         }
         max_mapped_size_ = std::max(max_mapped_size_, mapped_size_);
         mapped_mem_[i] = true;
@@ -205,8 +204,7 @@ void VmHeap::UnmapPhysMemory(size_t offset, size_t size) {
         mapped_size_ -= chunk_size_;
         free_mapped -= chunk_size_;
         mapped_mem_[i] = false;
-      }
-      else {
+      } else {
         assert(false);
       }
     }
@@ -256,8 +254,8 @@ address VmHeap::Alloc(size_t size) {
   if (memory->getUserData().data == nullptr) {
     memory->getUserData().data = hb;
   }
-  ClPrint(LOG_INFO, LOG_MEM_POOL,
-    "VmHeap Alloc: %p offset(%zx + %zx) hb(%p)", ptr, hb->Offset(), memory->getSize(), hb);
+  ClPrint(LOG_INFO, LOG_MEM_POOL, "VmHeap Alloc: %p offset(%zx + %zx) hb(%p)", ptr, hb->Offset(),
+          memory->getSize(), hb);
   return ptr;
 }
 
@@ -275,8 +273,8 @@ void VmHeap::Free(Memory* memory) {
   ScopedLock k(lock_);
   if (memory->getUserData().data != nullptr) {
     auto hb = reinterpret_cast<HeapBlock*>(memory->getUserData().data);
-    ClPrint(LOG_INFO, LOG_MEM_POOL, "VmHeap Free: %p offset(%zx + %zx) hb(%p)",
-      addr, hb->Offset(), memory->getSize(), hb);
+    ClPrint(LOG_INFO, LOG_MEM_POOL, "VmHeap Free: %p offset(%zx + %zx) hb(%p)", addr, hb->Offset(),
+            memory->getSize(), hb);
     FreeBlock(hb);
   }
   MemObjMap::RemoveMemObj(addr);
@@ -315,7 +313,7 @@ HeapBlock* VmHeap::AllocBlock(size_t un_size) {
   if (best != nullptr) {
     // Got one, but need to split it. Keep first part in free list,
     // put second part into busy list
-    HeapBlock *newblock = SplitBlock(best, size);
+    HeapBlock* newblock = SplitBlock(best, size);
     newblock->busy_ = true;
     InsertBlock(&busy_list_, newblock);
     free_size_ -= size;
@@ -380,7 +378,7 @@ void VmHeap::InsertBlock(HeapBlock** head, HeapBlock* blk) {
   blk->next_ = walk->next_;
   blk->prev_ = walk;
   if (walk->next_) {
-      walk->next_->prev_ = blk;
+    walk->next_->prev_ = blk;
   }
   walk->next_ = blk;
 }
@@ -402,7 +400,7 @@ void VmHeap::Join2Blocks(HeapBlock* first, HeapBlock* second) const {
   first->size_ = first->size_ + second->size_;
   first->next_ = second->next_;
   if (second->next_) {
-      second->next_->prev_ = first;
+    second->next_->prev_ = first;
   }
   delete second;
 }
@@ -413,12 +411,12 @@ void VmHeap::MergeBlock(HeapBlock** head, HeapBlock* blk) {
 
   // Merge with successor if possible
   if ((blk->next_ != nullptr) && (blk->offset_ + blk->size_ == blk->next_->offset_)) {
-      Join2Blocks(blk, blk->next_);
+    Join2Blocks(blk, blk->next_);
   }
 
   // Merge with predecessor if possible
   if ((blk->prev_ != nullptr) && (blk->prev_->offset_ + blk->prev_->size_ == blk->offset_)) {
-      Join2Blocks(blk->prev_, blk);
+    Join2Blocks(blk->prev_, blk);
   }
 }
 
@@ -465,12 +463,12 @@ void VmHeapArray::TrimPhysMemory(size_t unmap_threshold) {
   for (uint i = 0; i < kMaxArraySize; ++i) {
     // Check the threshold against the accumulated sizes in all heaps
     if (vm_heaps_[i]->created_ && [this]() {
-      uint64_t size = 0;
-      for (uint i = 0; i < kMaxArraySize; ++i) {
-        size += vm_heaps_[i]->FreeMappedSize();
-      }
-      return size;
-     }() > unmap_threshold) {
+          uint64_t size = 0;
+          for (uint i = 0; i < kMaxArraySize; ++i) {
+            size += vm_heaps_[i]->FreeMappedSize();
+          }
+          return size;
+        }() > unmap_threshold) {
       vm_heaps_[i]->TrimPhysMemory(unmap_threshold);
     } else {
       break;
@@ -524,4 +522,4 @@ void VmHeapArray::ResetMaxMappedSize() {
   }
 }
 
-} // namespace amd
+}  // namespace amd