Rework Vector_softRemove() and compact() operations

Remove the 'dirty_index' and 'dirty_count' members of Vector object.
Instead, let the callers of the Vector_softRemove() operation track the
'dirtyIndex' and pass it to Vector_compact() when needed.
(The new 'dirtyIndex' local variables are safe to migrate from 'int' to
'size_t' because no negative value is used.)

'dirty_index' is supposed to have shorter lifespan than a Vector
instance, and by removing the member we can reduce object size.

'dirty_count' is redundant and thus removed as well.

A boolean 'isDirty' member is added to a Vector object for ease of
debugging.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>

Author: Explorer09

ProcessTable.c

@@ -63,6 +63,10 @@ static void ProcessTable_cleanupEntries(Table* super) {
    Machine* host = super->host;
    const Settings* settings = host->settings;
 
+   // Lowest index of the row that is soft-removed. Used to speed up
+   // compaction.
+   int dirtyIndex = Vector_size(super->rows);
+
    // Finish process table update, culling any exit'd processes
    for (int i = Vector_size(super->rows) - 1; i >= 0; i--) {
       Process* p = (Process*) Vector_get(super->rows, i);
@@ -78,11 +82,13 @@ static void ProcessTable_cleanupEntries(Table* super) {
       if (pid > host->maxProcessId)
          host->maxProcessId = pid;
 
-      Table_cleanupRow(super, (Row*) p, i);
+      if (!Table_cleanupRow(super, &p->super, i)) {
+         dirtyIndex = i;
+      }
    }
 
    // compact the table in case of deletions
-   Table_compact(super);
+   Table_compact(super, dirtyIndex);
 }
 
 const TableClass ProcessTable_class = {

Table.c

@@ -329,7 +329,7 @@ void Table_prepareEntries(Table* this) {
 }
 
 // tidy up Row state after refreshing the table
-void Table_cleanupRow(Table* table, Row* row, int idx) {
+Row* Table_cleanupRow(Table* table, Row* row, int idx) {
    Machine* host = table->host;
    const Settings* settings = host->settings;
 
@@ -348,21 +348,28 @@ void Table_cleanupRow(Table* table, Row* row, int idx) {
          goto remove;
       }
    }
-   return;
+   return row;
 
 remove:
    Table_removeIndex(table, row, idx);
+   return NULL;
 }
 
 void Table_cleanupEntries(Table* this) {
+   // Lowest index of the row that is soft-removed. Used to speed up
+   // compaction.
+   int dirtyIndex = Vector_size(this->rows);
+
    // Finish process table update, culling any removed rows
    for (int i = Vector_size(this->rows) - 1; i >= 0; i--) {
       Row* row = (Row*) Vector_get(this->rows, i);
-      Table_cleanupRow(this, row, i);
+      if (!Table_cleanupRow(this, row, i)) {
+         dirtyIndex = i;
+      }
    }
 
    // compact the table in case of any earlier row removals
-   Table_compact(this);
+   Table_compact(this, dirtyIndex);
 }
 
 const TableClass Table_class = {

Table.h

@@ -84,10 +84,10 @@ void Table_prepareEntries(Table* this);
 
 void Table_cleanupEntries(Table* this);
 
-void Table_cleanupRow(Table* this, Row* row, int idx);
+Row* Table_cleanupRow(Table* this, Row* row, int idx);
 
-static inline void Table_compact(Table* this) {
-   Vector_compact(this->rows);
+static inline void Table_compact(Table* this, int dirtyIndex) {
+   Vector_compact(this->rows, dirtyIndex);
    this->needsSort = true;
 }
 

Vector.c

@@ -28,8 +28,7 @@ Vector* Vector_new(const ObjectClass* type, bool owner, int size) {
       .items = 0,
       .type = type,
       .owner = owner,
-      .dirty_index = -1,
-      .dirty_count = 0,
+      .isDirty = false,
    };
    return this;
 }
@@ -46,21 +45,11 @@ void Vector_delete(Vector* this) {
    free(this);
 }
 
-static inline bool Vector_isDirty(const Vector* this) {
-   if (this->dirty_count > 0) {
-      assert(0 <= this->dirty_index && this->dirty_index < this->items);
-      assert(this->dirty_count <= this->items);
-      return true;
-   }
-   assert(this->dirty_index == -1);
-   return false;
-}
-
 #ifndef NDEBUG
 
 static bool Vector_isConsistent(const Vector* this) {
    assert(this->items <= this->arraySize);
-   assert(!Vector_isDirty(this));
+   assert(!this->isDirty);
 
    return true;
 }
@@ -100,8 +89,7 @@ void Vector_prune(Vector* this) {
       }
    }
    this->items = 0;
-   this->dirty_index = -1;
-   this->dirty_count = 0;
+   this->isDirty = false;
    memset(this->array, '\0', this->arraySize * sizeof(Object*));
 }
 
@@ -256,10 +244,7 @@ Object* Vector_softRemove(Vector* this, int idx) {
    if (removed) {
       this->array[idx] = NULL;
 
-      this->dirty_count++;
-      if (this->dirty_index < 0 || idx < this->dirty_index) {
-         this->dirty_index = idx;
-      }
+      this->isDirty = true;
 
       if (this->owner) {
          Object_delete(removed);
@@ -270,35 +255,26 @@ Object* Vector_softRemove(Vector* this, int idx) {
    return removed;
 }
 
-void Vector_compact(Vector* this) {
-   if (!Vector_isDirty(this)) {
+void Vector_compact(Vector* this, int dirtyIndex) {
+   if (!this->isDirty)
       return;
-   }
 
-   const int size = this->items;
-   assert(0 <= this->dirty_index && this->dirty_index < size);
-   assert(this->array[this->dirty_index] == NULL);
+   assert(0 <= dirtyIndex);
+   if (dirtyIndex >= this->items)
+      return;
 
-   int idx = this->dirty_index;
+   assert(!this->array[dirtyIndex]);
 
-   // one deletion: use memmove, which should be faster
-   if (this->dirty_count == 1) {
-      memmove(&this->array[idx], &this->array[idx + 1], (this->items - idx - 1) * sizeof(this->array[0]));
-      this->array[this->items - 1] = NULL;
-   } else {
-      // multiple deletions
-      for (int i = idx + 1; i < size; i++) {
-         if (this->array[i]) {
-            this->array[idx++] = this->array[i];
-         }
+   for (int i = dirtyIndex + 1; i < this->items; i++) {
+      if (this->array[i]) {
+         this->array[dirtyIndex++] = this->array[i];
       }
-      // idx is now at the end of the vector and on the first index which should be set to NULL
-      memset(&this->array[idx], '\0', (size - idx) * sizeof(this->array[0]));
    }
+   int dirtyCount = this->items - dirtyIndex;
+   memset(&this->array[dirtyIndex], 0, dirtyCount * sizeof(this->array[0]));
 
-   this->items -= this->dirty_count;
-   this->dirty_index = -1;
-   this->dirty_count = 0;
+   this->items = dirtyIndex;
+   this->isDirty = false;
 
    assert(Vector_isConsistent(this));
 }

Vector.h

@@ -20,12 +20,13 @@ typedef struct Vector_ {
    int arraySize;
    int growthRate;
    int items;
-   /* lowest index of a pending soft remove/delete operation,
-      used to speed up compaction */
-   int dirty_index;
-   /* count of soft deletes, required for Vector_count to work in debug mode */
-   int dirty_count;
+
+   /* If true, the items would be freed when they are removed from the
+      vector. */
    bool owner;
+   /* Whether the Vector is pending a "compact" operation. This field
+      is currently only used for debugging. */
+   bool isDirty;
 } Vector;
 
 Vector* Vector_new(const ObjectClass* type, bool owner, int size);
@@ -54,7 +55,7 @@ Object* Vector_remove(Vector* this, int idx);
 Object* Vector_softRemove(Vector* this, int idx);
 
 /* Vector_compact reclaims space free'd up by Vector_softRemove, if any. */
-void Vector_compact(Vector* this);
+void Vector_compact(Vector* this, int dirtyIndex);
 
 void Vector_moveUp(Vector* this, int idx);