Concurrent Read / Write access

[artemkrachulov]

Good day, to all! I'm looking for some advice from you.

We have a feature containing the list of items. Initially, all operations performed with 0(n) complexity, read/write access performed within the main thread. Meanwhile amount of operations increased and I started thinking about optimization and moving heavy operations to background threads. With old legacy CGD we have a bunch of variants like barriers, locks, etc... to achieve this. But with TCA + structured concurrency I have no idea how to do that. Вelow is an example of my feature:

@Reducer
struct Feature {

  @ObservableState
  struct State {
       var array: [Item] = []
  }

  enum Action {
       
       case actionOne
       case actionTwo 
   }

   var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
              case .actionOne:
                  let array = [….]
                    
                  /// Array computations 
                  /// ….
                  state.array = array

	          return .none

              case .actionTwo:
                  let item =  state.array[id: …]
                  /// Item modifications  
                  /// …
                  state.array[id: ...] = item
                 return .none
             }
         }
    }
}

Asking for help 🙏

[mbrandonw]

Hi @artemkrachulov, I believe these docs should answer your question.

CPU intensive calculations can be moved to an effect and then the results sent back to the reducer in order to mutate the state's feature. The only thing to be cautious of is that seriously CPU intensive work isn't recommended to be performed in the cooperative thread pool, which is where Effect.run operates. So if you want to be a good citizen in a cooperative world, you may want to use an unsafe continuation and perform you work on a background DispatchQueue:

return .run { send in 
  await withUnsafeContinuation { continuation in 
    backgroundQueue.async {
      // Do work

      DispatchQueue.main.async { 
        // Send results back
        send(/*results*/)
      }
      continuation.resume()
    }
  }
}

However, if your CPU work doesn't take too much time you may not need to go this far.

[artemkrachulov]

Thank you for your reply!
Link CPU intensive calculations is "almost" the answer, but the trick is to have "safe" read/write access to the collection from different actions.

1. I found that we can use the "actor" type and the library has an "IsolatedActor" wrapper. Maybe try it
2. Or, like you shown above, wrap GCD into async/await and effect.