fix counting of reallocations (#8422)

### Description

reallocations were not counted correctly in the tracing

### Testing Instructions

<!--
  Give a quick description of steps to test your changes.
-->

Author: sokra

crates/turbo-tasks-malloc/src/counter.rs

@@ -49,6 +49,35 @@ impl ThreadLocalCounter {
         }
     }
 
+    fn update(&mut self, old_size: usize, new_size: usize) {
+        self.allocation_counters.deallocations += old_size;
+        self.allocation_counters.deallocation_count += 1;
+        self.allocation_counters.allocations += new_size;
+        self.allocation_counters.allocation_count += 1;
+        match old_size.cmp(&new_size) {
+            std::cmp::Ordering::Equal => {}
+            std::cmp::Ordering::Less => {
+                let size = new_size - old_size;
+                if self.buffer >= size {
+                    self.buffer -= size;
+                } else {
+                    let offset = size - self.buffer + TARGET_BUFFER;
+                    self.buffer = TARGET_BUFFER;
+                    ALLOCATED.fetch_add(offset, Ordering::Relaxed);
+                }
+            }
+            std::cmp::Ordering::Greater => {
+                let size = old_size - new_size;
+                self.buffer += size;
+                if self.buffer > MAX_BUFFER {
+                    let offset = self.buffer - TARGET_BUFFER;
+                    self.buffer = TARGET_BUFFER;
+                    ALLOCATED.fetch_sub(offset, Ordering::Relaxed);
+                }
+            }
+        }
+    }
+
     fn unload(&mut self) {
         if self.buffer > 0 {
             ALLOCATED.fetch_sub(self.buffer, Ordering::Relaxed);
@@ -93,6 +122,11 @@ pub fn remove(size: usize) {
     with_local_counter(|local| local.remove(size));
 }
 
+/// Adds some `size` to the global counter in a thread-local buffered way.
+pub fn update(old_size: usize, new_size: usize) {
+    with_local_counter(|local| local.update(old_size, new_size));
+}
+
 /// Flushes the thread-local buffer to the global counter. This should be called
 /// e. g. when a thread is stopped or goes to sleep for a long time.
 pub fn flush() {

crates/turbo-tasks-malloc/src/lib.rs

@@ -5,7 +5,7 @@ use std::{
     marker::PhantomData,
 };
 
-use self::counter::{add, flush, get, remove};
+use self::counter::{add, flush, get, remove, update};
 
 #[derive(Default, Clone, Debug)]
 pub struct AllocationInfo {
@@ -97,11 +97,7 @@ unsafe impl GlobalAlloc for TurboMalloc {
         let ret = mimalloc::MiMalloc.realloc(ptr, layout, new_size);
         if !ret.is_null() {
             let old_size = layout.size();
-            if old_size < new_size {
-                add(new_size - old_size);
-            } else {
-                remove(old_size - new_size);
-            }
+            update(old_size, new_size);
         }
         ret
     }
@@ -137,11 +133,7 @@ unsafe impl GlobalAlloc for TurboMalloc {
         let ret = std::alloc::System.realloc(ptr, layout, new_size);
         if !ret.is_null() {
             let old_size = layout.size();
-            if old_size < new_size {
-                add(new_size - old_size);
-            } else {
-                remove(old_size - new_size);
-            }
+            update(old_size, new_size);
         }
         ret
     }