Applied review comments

Author: nickolas-pohilets

stdlib/public/Concurrency/Actor.cpp

@@ -1032,16 +1032,18 @@ class DefaultActorImpl : public HeapObject {
 
   struct Padding {
     enum {
-      // Available space
-      x1 = (int)(sizeof(void *) * NumWords_DefaultActor),
+      // Max object size
+      x1 = (int)(sizeof(HeapObject) + sizeof(void *) * NumWords_DefaultActor),
       // ... subtracting size of footer
       x2 = x1 - (int)sizeof(Footer),
       // ... ensuring footer is aligned
       x3 = x2 - (int)(x2 % alignof(Footer)),
       // ... subtracting size of header
       x4 = x3 - (int)sizeof(Header),
       // ... subtracting padding before header
-      size = x4 - (int)((alignof(Header) - sizeof(HeapObject) % alignof(Header)) % alignof(Header))
+      x5 = x4 - (int)((alignof(Header) - sizeof(HeapObject) % alignof(Header)) % alignof(Header)),
+      // ... subtracting size of HeapObject
+      size = x5 - (int)sizeof(HeapObject),
     };
   };
   char padding[Padding::size];
@@ -1579,17 +1581,18 @@ void DefaultActorImpl::destroy() {
 #if SWIFT_CONCURRENCY_ACTORS_AS_LOCKS
   // TODO (rokhinip): Do something to assert that the lock is unowned
 #else
-  auto oldState = _status().load(std::memory_order_relaxed);
+  auto oldState = _status().load(std::memory_order_acquire);
   // Tasks on an actor are supposed to keep the actor alive until they start
   // running and we can only get here if ref count of the object = 0 which means
   // there should be no more tasks enqueued on the actor.
-  // TODO: It is not safe to access prioritisedJobs here, right?
   assert(!oldState.getFirstUnprioritisedJob() && "actor has queued jobs at destruction");
 
   if (oldState.isIdle()) {
+      assert(_prioritisedJobs().empty() && "actor has queued jobs at destruction");
       return;
   }
   assert(oldState.isRunning() && "actor scheduled but not running at destruction");
+  // In running state we cannot safely access prioritisedJobs to assert that it is empty.
 #endif
 }
 
@@ -1684,7 +1687,7 @@ retry:;
       assert(oldState.getMaxPriority() == JobPriority::Unspecified);
       assert(!oldState.getFirstUnprioritisedJob());
       // We cannot assert here that prioritisedJobs is empty,
-      // because lock is not held yet. Raise a flag to after getting the lock.
+      // because lock is not held yet. Raise a flag to assert after getting the lock.
       assertNoJobs = true;
     }