Remove dead code with task nearest deadline logic

Radar-Id: rdar://problem/88093007

Author: rokhinip

include/swift/ABI/MetadataValues.h

@@ -2343,8 +2343,6 @@ class JobFlags : public FlagSet<uint32_t> {
 
 /// Kinds of task status record.
 enum class TaskStatusRecordKind : uint8_t {
-  /// A DeadlineStatusRecord, which represents an active deadline.
-  Deadline = 0,
 
   /// A ChildTaskStatusRecord, which represents the potential for
   /// active child tasks.

include/swift/ABI/TaskStatus.h

@@ -79,38 +79,6 @@ class TaskStatusRecord {
   void spliceParent(TaskStatusRecord *newParent) { Parent = newParent; }
 };
 
-/// A deadline for the task.  If this is reached, the task will be
-/// automatically cancelled.  The deadline can also be queried and used
-/// in other ways.
-struct TaskDeadline {
-  // FIXME: I don't really know what this should look like right now.
-  // It's probably target-specific.
-  uint64_t Value;
-
-  bool operator==(const TaskDeadline &other) const {
-    return Value == other.Value;
-  }
-  bool operator<(const TaskDeadline &other) const {
-    return Value < other.Value;
-  }
-};
-
-/// A status record which states that there's an active deadline
-/// within the task.
-class DeadlineStatusRecord : public TaskStatusRecord {
-  TaskDeadline Deadline;
-
-public:
-  DeadlineStatusRecord(TaskDeadline deadline)
-      : TaskStatusRecord(TaskStatusRecordKind::Deadline), Deadline(deadline) {}
-
-  TaskDeadline getDeadline() const { return Deadline; }
-
-  static bool classof(const TaskStatusRecord *record) {
-    return record->getKind() == TaskStatusRecordKind::Deadline;
-  }
-};
-
 /// A status record which states that a task has one or
 /// more active child tasks.
 class ChildTaskStatusRecord : public TaskStatusRecord {

include/swift/Runtime/Concurrency.h

@@ -643,31 +643,6 @@ void swift_task_localValuePop();
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_localsCopyTo(AsyncTask* target);
 
-/// This should have the same representation as an enum like this:
-///    enum NearestTaskDeadline {
-///      case none
-///      case alreadyCancelled
-///      case active(TaskDeadline)
-///    }
-/// TODO: decide what this interface should really be.
-struct NearestTaskDeadline {
-  enum Kind : uint8_t {
-    None,
-    AlreadyCancelled,
-    Active
-  };
-
-  TaskDeadline Value;
-  Kind ValueKind;
-};
-
-/// Returns the nearest deadline that's been registered with this task.
-///
-/// This must be called synchronously with the task.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-NearestTaskDeadline
-swift_task_getNearestDeadline(AsyncTask *task);
-
 /// Switch the current task to a new executor if we aren't already
 /// running on a compatible executor.
 ///

stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

@@ -373,10 +373,6 @@ OVERRIDE_TASK_STATUS(task_escalate, JobPriority,
                      swift::, (AsyncTask *task, JobPriority newPriority),
                      (task, newPriority))
 
-OVERRIDE_TASK_STATUS(task_getNearestDeadline, NearestTaskDeadline,
-                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
-                     swift::, (AsyncTask *task), (task))
-
 #undef OVERRIDE
 #undef OVERRIDE_ACTOR
 #undef OVERRIDE_TASK

stdlib/public/Concurrency/TaskStatus.cpp

@@ -423,10 +423,6 @@ void swift::_swift_taskGroup_detachChild(TaskGroup *group,
 /// Perform any cancellation actions required by the given record.
 static void performCancellationAction(TaskStatusRecord *record) {
   switch (record->getKind()) {
-  // Deadlines don't require any special support.
-  case TaskStatusRecordKind::Deadline:
-    return;
-
   // Child tasks need to be recursively cancelled.
   case TaskStatusRecordKind::ChildTask: {
     auto childRecord = cast<ChildTaskStatusRecord>(record);
@@ -518,10 +514,6 @@ static void swift_task_cancelImpl(AsyncTask *task) {
 static void performEscalationAction(TaskStatusRecord *record,
                                     JobPriority newPriority) {
   switch (record->getKind()) {
-  // Deadlines don't require any special support.
-  case TaskStatusRecordKind::Deadline:
-    return;
-
   // Child tasks need to be recursively escalated.
   case TaskStatusRecordKind::ChildTask: {
     auto childRecord = cast<ChildTaskStatusRecord>(record);
@@ -634,52 +626,5 @@ static swift_task_escalateImpl(AsyncTask *task, JobPriority newPriority) {
   return newStatus.getStoredPriority();
 }
 
-/**************************************************************************/
-/******************************** DEADLINE ********************************/
-/**************************************************************************/
-SWIFT_CC(swift)
-static NearestTaskDeadline swift_task_getNearestDeadlineImpl(AsyncTask *task) {
-  // We don't have to worry about the deadline records being
-  // concurrently modified, so we can just walk the record chain,
-  // ignoring the possibility of a concurrent cancelling task.
-
-  // Load the current state.
-  auto &status = task->_private()._status();
-  auto oldStatus = status.load(std::memory_order_relaxed);
-
-  NearestTaskDeadline result;
-
-  // If it's already cancelled, we're done.
-  if (oldStatus.isCancelled()) {
-    result.ValueKind = NearestTaskDeadline::AlreadyCancelled;
-    return result;
-  }
-
-  // If it's locked, wait for the lock; we can't safely step through
-  // the RecordLockStatusRecord on a different thread.
-  if (oldStatus.isStatusRecordLocked()) {
-    waitForStatusRecordUnlock(task, oldStatus);
-    assert(!oldStatus.isStatusRecordLocked());
-  }
-
-  // Walk all the records looking for deadlines.
-  result.ValueKind = NearestTaskDeadline::None;
-  for (const auto *record: oldStatus.records()) {
-    auto deadlineRecord = dyn_cast<DeadlineStatusRecord>(record);
-    if (!deadlineRecord) continue;
-    auto recordDeadline = deadlineRecord->getDeadline();
-
-    // If we already have a deadline, pick the earlier.
-    if (result.ValueKind == NearestTaskDeadline::Active) {
-      if (recordDeadline < result.Value)
-        result.Value = recordDeadline;
-    } else {
-      result.Value = recordDeadline;
-      result.ValueKind = NearestTaskDeadline::Active;
-    }
-  }
-  return result;
-}
-
 #define OVERRIDE_TASK_STATUS COMPATIBILITY_OVERRIDE
 #include COMPATIBILITY_OVERRIDE_INCLUDE_PATH

unittests/runtime/CompatibilityOverrideConcurrency.cpp

@@ -255,8 +255,4 @@ TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_task_escalate) {
   swift_task_escalate(nullptr, {});
 }
 
-TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_task_getNearestDeadline) {
-  swift_task_getNearestDeadline(nullptr);
-}
-
 #endif