Início / coding / Perguntas / 78610314
Accepted
bli00
Asked: 2024-06-12 09:36:04 +0800 CST

Segurança de simultaneidade durante atualizações de frames no Swift

  • 772

Eu tenho um método chamado renderque é chamado em cada quadro para desenhar algo na tela usando Metal. Ele está renderizando uma série de pontos armazenados dentro da classe. No entanto, ocasionalmente preciso atualizar esse conjunto de pontos. Estou lutando para encontrar uma solução que possa atualizar esses pontos de maneira segura para a simultaneidade.

Ou seja, ao rendertentar acessar esse array, outro thread pode estar atualizando-o, causando uma falha. Além disso, renderé síncrono e não pode bloquear ou aguardar a atualização. Este parece ser um problema de simultaneidade comum, por isso estou procurando ajuda aqui para ver quais soluções existem.

Para generalizar o problema - há alguma função síncrona que é chamada com muita frequência, ela precisa de acesso a um dado que pode ser atualizado por outro thread. Eu tenho controle sobre o rendermétodo e o "outro" thread que faz a atualização. Como posso evitar que uma condição de corrida trave o aplicativo? (só não precisa travar, não há considerações de "correção" dos dados)

Uma possível solução que eu hipotetizei é usar atômicos. Não tenho certeza de como isso poderia ser feito, especialmente em Swift (não acha que Swift tem atômicos?)

EDITAR:

Tentarei adicionar mais contexto aqui, mas pode ser difícil adicionar um MRE, considerando que parte do que estou implementando está guardado em um repositório privado ao qual não tenho acesso.

Resumindo, estou tentando implementar uma camada personalizada do MapBox seguindo este exemplo . Os detalhes desta renderfunção específica no exemplo são irrelevantes, pois meu método de renderização precisa fazer algo completamente diferente, mas seria algo assim em pseudocódigo:

class MyCustomLayer: NSObject, CustomLayerHost {
    var locationData: [CLLocation] = []
    
    func render(...) {
        // calculate the viewport from the parameters
        let viewport = ...
        if viewport.fitSomeCondition {
            // fetch new location data. This can't block and needs to happen async
            fetchLocationDataFromServer(viewport: viewport)
            // need to somehow update the locationData
        }
        
        // render locationData
    }
}

Aqui locationDataestá uma matriz de longitudes e latitudes e renderestá separada do CustomLayerHostprotocolo do MapBox iOS SDK . O código-fonte de como CustomLayerHosté tratado não está disponível ao público, mas aqui está a declaração do cabeçalho:

/**
 * Render the layer. This method is called once per frame.
 *
 * This method is called if underlying map rendering backend uses Metal graphic API.
 *
 * @param The `parameters` that define the current camera position.
 * @param The MTLCommandBuffer used to render all map layers.
 * Use to create new command encoders. Do not submit as there could be map
 * layers following this custom layer in style's layer list and those won't get
 * to be encoded.
 * @param The MTLRenderPassDescriptor that defines rendering map to view drawable.
 *
 */
- (void)render:(nonnull MBMCustomLayerRenderParameters *)parameters
mtlCommandBuffer:(nonnull id<MTLCommandBuffer>)mtlCommandBuffer
mtlRenderPassDescriptor:(nonnull MTLRenderPassDescriptor *)mtlRenderPassDescriptor;

Entendo que este não é um MRE, mas espero que ajude a tornar a questão mais clara.

swift

1 respostas

  1. Best Answer

    Se você está apenas tentando evitar a corrida de dados locationData, recomendo adicionar alguma sincronização. Por exemplo, em cenários de alto desempenho, podemos optar por uma sincronização baseada em bloqueio:

    import os.lock

class MyCustomLayer: NSObject, CustomLayerHost {
    private let lock = OSAllocatedUnfairLock()    // or `NSLock` would likely be fine, too
    private var _locationData: [CLLocation] = []
    
    // synchronized access to _locationData
    
    private var locationData: [CLLocation] {
        get { lock.withLock { _locationData } }
        set { lock.withLock { _locationData = newValue } }
    }

    func render() {
        // calculate the viewport from the parameters
        let viewport = …

        // fetch locations if necessary
        if viewport.fitSomeCondition {
            fetchLocationDataFromServer()
        }

        // in the meantime, fetch copy of `locationData`
        let locationsToRender = locationData

        // now render `locationsToRender`, our local copy
        …
    }
    
    func fetchLocationDataFromServer() {
        let request: URLRequest = …
        let task = URLSession.shared.dataTask(with: request) { [self] data, response, error in
            locationData = …
        }
        task.resume()
    }
}

    Existem muitos padrões de sincronização (filas seriais GCD, atores, etc.), mas para algo que precisa ser executado tão frequentemente quanto quadro a quadro, eu poderia me inclinar para um mecanismo de sincronização com melhor desempenho, ou seja, bloqueios injustos, mostrados acima .

    Observe que queremos minimizar o número de sincronizações, portanto, eu evitaria referenciar locationDatarepetidamente dentro de render, mas sim fazê-lo uma vez, atribuindo-o a uma variável local.

    Além disso, está além do escopo da questão, mas pense muito fitSomeConditione evite solicitações de rede redundantes ou simultâneas.

    Se valer a pena, posso considerar mover essa sincronização baseada em bloqueio para seu próprio wrapper de propriedade:

    @propertyWrapper
class Synchronized<T> {
    private let lock = OSAllocatedUnfairLock()
    private var _wrappedValue: T
    
    var wrappedValue: T {
        get { lock.withLock { _wrappedValue } }
        set { lock.withLock { _wrappedValue = newValue } }
    }
    
    init(wrappedValue: T) {
        _wrappedValue = wrappedValue
    }
}

    E isso simplifica MyCustomLayer:

    class MyCustomLayer: NSObject, CustomLayerHost {
    @Synchronized private var locationData: [CLLocation] = []
    
    func render() {
        let viewport = …

        if viewport.fitSomeCondition {
            fetchLocationDataFromServer()
        }

        // fetch copy of `locationData`
        let locationsToRender = locationData

        // now render `locationsToRender`, our local copy
        …
    }
    
    func fetchLocationDataFromServer() {
        let request: URLRequest = …
        let task = URLSession.shared.dataTask(with: request) { [self] data, response, error in
            locationData = …
        }
        task.resume()
    }
}
    • 1

relate perguntas