Prepare for a more real task-local alloocator implementation.

Author: rjmccall

stdlib/public/Concurrency/TaskAlloc.cpp

@@ -17,15 +17,50 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "TaskPrivate.h"
 #include "swift/Runtime/Concurrency.h"
 #include <stdlib.h>
 
 using namespace swift;
 
+namespace {
+
+class TaskAllocator {
+public:
+  void *alloc(size_t size) {
+    return malloc(size);
+  }
+
+  void dealloc(void *ptr) {
+    free(ptr);
+  }
+};
+
+static_assert(sizeof(TaskAllocator) <= sizeof(AsyncTask::AllocatorPrivate),
+              "task allocator must fit in allocator-private slot");
+
+static_assert(alignof(TaskAllocator) <= alignof(decltype(AsyncTask::AllocatorPrivate)),
+              "task allocator must not be more aligned than "
+              "allocator-private slot");
+
+} // end anonymous namespace
+
+void swift::_swift_task_alloc_initialize(AsyncTask *task) {
+  new (task->AllocatorPrivate) TaskAllocator();
+}
+
+static TaskAllocator &allocator(AsyncTask *task) {
+  return reinterpret_cast<TaskAllocator &>(task->AllocatorPrivate);
+}
+
+void swift::_swift_task_alloc_destroy(AsyncTask *task) {
+  allocator(task).~TaskAllocator();
+}
+
 void *swift::swift_task_alloc(AsyncTask *task, size_t size) {
-  return malloc(size);
+  return allocator(task).alloc(size);
 }
 
 void swift::swift_task_dealloc(AsyncTask *task, void *ptr) {
-  free(ptr);
+  return allocator(task).dealloc(ptr);
 }

stdlib/public/Concurrency/TaskPrivate.h

@@ -0,0 +1,32 @@
+//===--- TaskPrivate.h - Concurrency library internal interface -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Internal functions for the concurrency library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_CONCURRENCY_TASKPRIVATE_H
+#define SWIFT_CONCURRENCY_TASKPRIVATE_H
+
+namespace swift {
+
+class AsyncTask;
+
+/// Initialize the task-local allocator in the given task.
+void _swift_task_alloc_initialize(AsyncTask *task);
+
+/// Destsroy the task-local allocator in the given task.
+void _swift_task_alloc_destroy(AsyncTask *task);
+
+} // end namespace swift
+
+#endif