При работе со Swift Concurrency часто хочется посмотреть, как работают созданные асинхронные задачи в приложении: узнать количество задач, время создания и длительность их выполнения. Посмотреть, на каких потоках и с какими приоритетами они выполняются.

В Xcode 14 появился специальный шаблон профилирования в Xcode Instruments — Swift Concurrency. Он позволяет наглядно визуализировать работу с асинхронным кодом.

Я — Светлана Гладышева, iOS-разработчик компании Surf. Давайте разберёмся, что нам может показать Swift Concurrency шаблон и как его использовать. А также на простых примерах посмотрим, какие ошибки можно обнаружить с его помощью.

Обзор инструмента

Чтобы воспользоваться шаблоном Swift Concurrency, нужно в меню Xcode выбрать пункт Product->Profile или нажать ⌘I. Затем в появившемся окне нужно выбрать Swift Concurrency.

Нам нужно записать действия, которые хотим исследовать. Как и в других инструментах из Xcode Instruments, чтобы начать запись, нажимаем на кнопку Start recording.

В приложении совершаем действия, которые нужно отследить. Останавливаем запись той же кнопкой.

В итоге увидим вот такое окно:

Окно инструмента разделено на две части. В верхней части — временная шкала, с помощью которой можно узнать общую информацию о задачах, акторах и потоках, а также об использовании CPU. В нижней части — более подробная информацию о том, что выделено синим цветом в верхней части.

Рассмотрим верхнюю часть. Из раздела Swift Tasks можем узнать, сколько задач выполнялось в определенный момент времени.

Running tasks — количество выполняющихся одновременно задач.

Alive tasks — количество незавершённых задач. Помимо выполняющихся задач, сюда также входят задачи, которые чего-либо ожидают.

Total tasks — общее число созданных задач до определённого момента времени.  

Swift actors — показывает количество акторов в определённый момент времени.

Также бывает полезно рядом с информацией о задачах и акторах увидеть информацию об использовании CPU: она здесь тоже есть.

Ещё на временную шкалу можно прикрепить отдельную задачу, актора или поток, чтобы увидеть информацию только об одной этой сущности. Для этого нужно кликнуть по сущности, которую хотим прикрепить, правой кнопкой мыши и выбрать пункт «Pin in timeline».

После этого сущность появится на временной шкале в средней части окна.

Нижняя часть показывает более подробную информацию о задачах, акторах, потоках или CPU. Для каждой сущности есть несколько режимов. Давайте рассмотрим те из них, которые, на мой взгляд, наиболее полезные.

Task Forest показывает графическое представление об иерархии задач: можно посмотреть, какие задачи родительские, какие дочерние.

Task Lifetime показывает время жизни каждой задачи, а также время её создания.

Task States показывает, сколько времени каждая задача проводит в различных состояниях: creating, running, continuation, ending.

Если прикрепить к временной шкале задачу, для неё становится доступен режим Narrative. В нём можно узнать самую подробную информацию о задаче, включая то, на каких потоках и с каким приоритетом она выполнялась. Также тут можно увидеть, чего задача ожидает и как долго.

Для акторов есть полезный режим Actor Execution. В нём можно посмотреть, какие задачи выполнялись на этом акторе, как долго и в каком потоке.

Пример 1

Предположим, мы хотим выполнять параллельно сложные и долгие вычисления. Есть такой код:

func onButtonTap() {
    Task {
        let calculatedValues = await withTaskGroup(of: Int.self) { group in
            for _ in 0 ..< numberOfValues {
                group.addTask {
                    return await self.calculator.calculateValue()
                }
            }
           	
            var result = [Int]()
            for await value in group {
                result.append(value)
            }
            return result
        }
        processValues(calculatedValues)
    }
}

Запустим для этого кода инструмент и увидим вот такую картину:

Посмотрев на строку Running Tasks, мы сразу же видим, что большую часть времени выполняется только одна задача. Мы же хотим, чтобы выполнялось несколько задач одновременно.

В нижней части выберем одну из задач и прикрепим её к временной шкале. Теперь в нижней части можем посмотреть для неё Narrative.

Мы видим, что задача выполнялась на акторе Calculator. Чтобы обеспечить потокобезопасность, акторы в Swift допускают одновременное выполнение только одной задачи. Таким образом мы выяснили: этот актор и есть причина того, что задачи выполнялись последовательно по одной.

На простом примере мы убедились, что Swift Concurrency Instrument может помочь обнаружить проблему в коде. Если бы в вашем коде задач и акторов было намного больше, разобраться в коде было бы сложнее: визуализация упростила бы понимание того, что происходит.

Пример 2

Усложним предыдущий пример. Теперь мы хотим сохранять каждое посчитанное значение сразу после того, как оно вычислилось.

func onButtonTap() {
    Task {
        let calculatedValues = await withTaskGroup(of: Int.self) { group in
            for _ in 0 ..< numberOfValues {
                group.addTask {
                    let value = self.calculateValue()
                    await self.save(value)
                    return value
                }
            }
           	
            var result = [Int]()
            for await value in group {
                result.append(value)
            }
            return result
        }
        processValues(calculatedValues)
    }
}

Метод save выглядит так:

func save(_ value: Int) async {
    Task {
        await store.save(value)
    }
}

Давайте запустим Instruments и посмотрим, что происходит. В Task States мы видим вот такую картину:

Большинство задач на сохранение выполняются в конце — в начале выполняются в основном только задачи на вычисление. Но нам надо сохранять значения сразу же, как только они будут вычислены.

Давайте прикрепим несколько задач к временной шкале и посмотрим на их Narrative:

Мы видим, что приоритет у них одинаковый: User Initiated. Задачи на сохранение создаются позже, а приоритет у них такой же, как и у задач на вычисление. Поэтому очередь до них доходит только после завершения задач на вычисление.

Наглядное представления о работе задач и их приоритетах помогло обнаружить проблему неправильных приоритетов.

Пример 3

Давайте посмотрим на такой код:

func getMessages() async -> [Message] {
    await withCheckedContinuation { continuation in
        fetchMessages { messages in
            continuation.resume(returning: messages)
        }
    }
}

На первый взгляд здесь всё хорошо: мы вызываем continuation.resume ровно один раз. Но, запустив Swift Concurrency Instrument, увидим вот такую картину:

Есть одна задача, которая выполняется очень долго. В Task States мы видим, что эта задача висит в состоянии continuation. Задача должна была быстро завершиться, но не завершилась.

В правой нижней части окна инструмента есть Creation Backtrace, с помощью которого можно легко найти место в коде, где эта задача создается. Давайте перейдём в это место в коде. Так как в методе getMessages все хорошо, посмотрим на метод fetchMessages, который вызывается внутри withCheckedContinuation:

func fetchMessages(completion: @escaping ([Message]) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        guard
            let data = data,
            let messages = try? JSONDecoder().decode([Message].self, from: data)
        else {
            return
        }

        completion(messages)
    }.resume()
}

В этом методе при ошибке не вызывается completion callback. Из-за этого задача долго не завершалась и висела в статусе сontinuation.

В таком простом примере ошибку использования continuation видно сразу. Но в реальном проекте логика может быть намного более сложной, и это уже не будет так очевидно.

Если вы используете checked continuation, в такой ситуации консоль выведет ошибку. Если вам по каким-то причинам нужно использовать unchecked continuation, в консоли не будет ошибок. В таком случае этот инструмент незаменим, чтобы отслеживать долго висящие continuation.

Шаблон Swift Concurrency в Xcode Instruments был создан, чтобы выявлять проблемы в асинхронном коде. Если вы используете Swift Concurrency, этот инструмент поможет лучше понимать, что происходит. Особенно эффективен он будет, если в приложении есть сложная логика с большим количеством асинхронных задач.

Демонстрацию использования инструмента также можно посмотреть в видео с WWDC 2022.

Больше полезного про iOS — в нашем телеграм-канале Surf iOS Team. Публикуем кейсы, лучшие практики, новости и вакансии Surf. Присоединяйтесь >>