DEV Community: Priya Raman

Swift - Structured Concurrency - Actor

Priya Raman — Thu, 21 Dec 2023 17:54:08 +0000

Actor - Way to serve the incoming requests with shared mutable state, protects data from inadvertently modified/accessed. These are otherwise enforced by Locks, serial queues, Semaphores.

Thread safe requests for the shared state - ex, Multiple reads during write
Serialize multiple write requests. ex, write-1 vs write-2 initiated at the same time.

actor is similar to class nominal type, reference type, has methods, properties isolated to that actor, can have protocol conformance. NO inheritance - so no convenience initializers, no final or no override with actors.
Properties and methods within actors are async in nature, so, any access to properties/methods outside actor should be marked with await and any references of other instances of actor within the actor should also be with await while internal references within actor of properties are synchronous in nature so, it could be direct access unless its within a Task.detached which would require await. -- Every access request to actor's method or property creates a potential suspension point - meaning the request could be served by the actor right away or within a moment or 2,basically saying that "serve me as soon as you can"
Internally, its a private serial queue processing 1 request at a time in the order in which the requests are received unless specified with priority escalation.
There could be unprotected state within the actor which could be accessed without await but should be specifically marked so.
Care should be taken that internally it will process only 1 request at a time by a single thread as actor is specifically to avoid ambiguity in shared mutable state and avoid data races, so performance consideration to handle multiple requests at a time is not the architecture design of actor. Creating multiple instances does not cause any perf issue rather the time spent on potential suspension points when called by the requests is something that's bound to happen.
Function Parameter based isolation: Ability for external functions to execute within the specified actor's isolated context as if this function was defined within the actor, meaning the function could access the actor's properties or methods freely/synchronously but this method could called only using await. Though not marked async, it would still be executed in actor's isolated context single thread.

actor CachedData {
 private var variable1, variable2, ...
 func doSomething() {
 }
}

class anotherClass {
func anotherFunc(data: isolated CachedData) {
print(data.variable1)
print(data.variable2)
}
init() {
  await anotherFunc(CachedData())
}

Non isolated functions : An inverse of external isolated functional parameters.

-- Can access only constant properties which are thread safe in nature and other non-isolated methods.

-- Could be accessed synchronously by external methods not within the actor without using await.

-- If this method requires accessing any actor isolated properties or methods, it would be as if this method is external to the actor and accessed through await.

actor SampleActor {
 private var str1 = ""
 private var int1 = 0
 private let str2 = "hi"
 func doSomething() {
 }
 nonisolated func doNonIsolatedCommonForActor() {
  print(str2)
 }
 nonisolated func doNonIsolatedCommonForSameActor() {
  await doSomething()
  print(await str1)
 }
}
let actorInstance = SampleActor()
actorInstance.doNonIsolatedCommonForActor()
actorInstance.doNonIsolatedCommonForSameActor()
await actorInstance.doSomething()

My Notes as understood from HackingWithSwift Structured Concurrency series.

Swift - Structured Concurrency - Notes about TaskGroup

Priya Raman — Tue, 19 Dec 2023 21:45:02 +0000

TaskGroup - Concurrent requests similar to DispatchGroup

withTaskGroup - No throw variant. grp conforms to AsyncSequence, so return value could be collated by for await loop or while let item = await grp.next() or await grp.reduce(initial, transform). .waitForAll() will discard the result though. -- returnValue for each Task within the group should be the same representing await withTaskGroup(String.self) but overall group could return a different data type as well with collated Task results.

let something = await withTaskGroup(String.self) { grp -> String
grp.addTask {
...
...
return "abc" 
}
grp.addTask {
...
...
return "def" 
}
var collectedReturn = ""

//3 Ways to fetch
for await val in grp {
 // indv return from indv task and collate
 collectedReturn += val
}
return collectedReturn }
//OR
return await grp.reduce(""){$0 += $1} }
//OR
while let val = await grp.next() {
 collectedReturn +=val
}
return collectedReturn }
print("val is \(something)") // prints val is abcdef

withThrowingTaskGroup - can throw Errors, grp conforms to AsyncSequence, so return value could be collated by for try await loop or while let item = try await grp.next() or try await grp.reduce(initial, transform). .waitForAll() will discard the result though. -- returnValue for each Task within the group should be the same representing try await withTaskGroup([Model].self) but overall group could return a different data type as well with collated Task results.

func loadStories() async {
        do {
            let allStories = try await withThrowingTaskGroup(of: [Model].self) { grp -> [Model] in

                for i in 1...5 {
                    grp.addTask {
                        let url = URL(string: "URL")!
                        let (data, _) = try await URLSession.shared.data(from: url)
                        _//if Task.isCancelled { return []}_
                        return try JSONDecoder().decode([Model].self, from: data)
                    }
                }
                _//grp.cancelAll()_
                //return try await grp.reduce(into: [Model]()) { $0 += $1 }
                var collectedItems = [Model]()
                while let item = try await grp.next() {
                    collectedItems.append(contentsOf: item)
                }
                return collectedItems

            }
            newsItems = allStories.sorted {
                $0.id < $1.id
            }
        } catch let error {
            if error as! CancelError == CancelError.Icancelled {
                print("I cancelled")
            }
            print("Error \(error.localizedDescription)")
        }
    }

Task Cancellation: .cancelAll() Method on grp, wont cancel unless check for cancellation is cooperative but seems to work even otherwise, meaning check for cancellation such as if Task.isCancelled or try Task.checkCancellation calls within the grp's individual task as shown above in the comments.
Heterogenous Return type for each task in Taskgroup is possible with wrapping up actual return type with enum so that each task can return same enum with different case having different associated value type. And still, taskGroup can ultimately return different data type as well.

My Notes as understood from HackingWithSwift Structured Concurrency series.

Swift - Structured Concurrency - Notes about Task

Priya Raman — Mon, 18 Dec 2023 18:39:18 +0000

Task - Independent chunk of work in async context.

async let doSomething = funcCall() is syntactic sugar for a creating a task underneath + await result.
Task Priority - High[~userInitiated], medium to low[~utility] and then, background.
-- Child task inherits from parent, UI task from Main thread inherits userInitiated, if neither, gets nil or Swift queries to figure out the priority.
-- Task.currentPriority gives current priority
Task priority escalation scenarios.
-- Task B with low priority gets invoked by Task A with high priority, Task B priority gets elevated to Task A's priority. Task.currentPriority for Task B is also high.
-- Task B with low priority is getting executed by an actor which has enqueued Task A with high priority, Task B priority gets elevated to Task A's priority. Task.currentPriority is still the same but executes faster though.
Task Syntax

let fetchTask = Task(priority: .high) {() -> returnValueType  in 
try ...
return returnValueType
} 
do {  
  let val = try await fetchTask.value // .value gives the   
                                      return value.
} catch {
  print("Error")
}

Inferences: -- try await task.value gives the return value with specified return type as part of Task closure. -- Another way to retrieve value is through .result and .get(), it returns the Result struct with Return type and Error as values, so, let result = await task.result() but it could be TRIED when the result is accessed as let val = try result.get(), this is helpful to the caller as it could decide when exactly to throw and deal with the error and result leading to just pass around the encapsulated result as a whole to the caller chain up further. -- Tasks get kickstarted the moment we initialize, it runs concurrently with other code as below. fetchUpdates Started 14:46:48:1850 - actual async function call headlinesTask Started 14:46:48:1850 ScoreTask Started 14:46:48:1850 scoreTask Value Started 14:46:48:1850 headlinesTask API Ended 14:46:48:2120 ScoreTask API ended 14:46:48:2120 scoreTask Value Ended 14:46:48:2130 headlinesTask Value Started 14:46:48:2130 headlinesTask Value Ended 14:46:48:2130 fetchUpdates Ended 14:46:48:2520 We can see that tasks started at the same time and value retrieval was hit at the same time. once API ended, value retrieval ended and moved on to 2nd value retrieval.
@State property could be accessed from any thread, the view will be refreshed on Main thread.
Task and .taskmodifier to view - modifier is intelligent enough to be bound to life time of the view so, will be cancelled after view is moved out of memory. Task runs to completion until its either complete or cancelled. if async API call is attached to .task modifier, and if view tends to get recreated, API gets called though with URLSession, it might be cached. Dynamic identifier conforming to Equatable can be applied to .task modifier, so API could get called based on equatable value.
Task Cancellation
-- Task.isCancelled -> Bool Static method within Task definition
-- try Task.checkCancellation : Static method within Task definition that throws TaskCancellation Error.
-- .cancel() method on task instance.
-- URLSession throws cancellation Errors if call is cancelled.
Task vs detachedTask
-- Task/ detachedTask is differentiated by its priority, local values and actor context
--- Priority: Task is inherently defined by its context in which its executed, meaning it inherits the parent priority, if button action initiates the task, it gains userinitiated priority and runs the task with that priority. WHILE, Task.detached does not have any parent to inherit priority so, its nil or something we prescribe.
--- local values: defined as static types within task letting us share the values within the specific task. WHILE, Task.detached does not have any parent to inherit local values so, no local values will be inherited.
---- Task Local value: Struct/Class/Enum/Actor with static dataType associated @TaskLocal property wrapper. It can have different meaning ~Values according to the Task in which its associated with, similar to local and global variables scope. Task starts and ends with try await Type.$staticVar.withValue(customVal) and can be nested as well, with global scope still retaining original declared value.
--- actor isolation: When a task is defined within actor,its isolated to that actor - meaning other parts of the code could be used synchronously within the task. Everything within a task executes sequentially and synchronously though it might entail other API calls. Task has the control of code execution flow.WHILE, Task.detached does not have any parent or any control over how the code execution flows, so, within detachedTask, any code run requiring async context runs concurrently, so, to sequence the task, we would have to await the async function call to make it the way we want the task.detached to run. As it does not have a parent, it has greater restriction towards executing other pieces of code even within that actor.
Task Sleep - try await Task.sleep(nanoSeconds: 3_000_000_000) , requires try as if the task is cancelled, it will throw a cancellation error inherently, requires await as it causes the execution to be suspended. It wont block the underlying thread, it will go on to execute something else.
Voluntarily suspend Task - Task.yield() , gives Swift a chance to run other priority tasks if present by suspending current task. This is a suggestion to Swift runtime, so, the current task could or need not be suspended.

My Notes as understood from HackingWithSwift Structured Concurrency series.

SwiftUI - Basic Core Image Processing

Priya Raman — Wed, 13 Dec 2023 17:36:36 +0000

Steps to create a processed image based on CI filter in SwiftUI

Create CIFilter instance to be sepia or any filter type.
Convert selectedItem - PhotosPickerItem into Data format using loadTransferable method.
Convert imageData into UIImage
For Core Image processing, Image needs to be in CI format, so convert UIImage into CIImage.
CIFilter is a specific container within Core Image that can accept input CI image and generate output CI image and apply filter in between.
Set CurrentFilter's CI inputImg using setValue with Img key.
Set CurrentFilter's intensity or any valid inputKeys with respective float value
Fetch CurrentFilter's CI outputImg
Now that processing within CI is over, its time to convert that to proper pixels in Coregraphics.
CIContext can create cgImage with this generated CIImage with applied filter to the fullest extent size.
Back convert from CGImage to UIImage as CIImage conversion is not needed as image has been processed.
Back convert from UIImage to Image initializer in SwiftUI.

My Notes as understood from HackingWithSwift 100 days of SwiftUI.