Parallélisme en python avec un dictionnaire

Salut, voilà, j’ai un problème qui est très probablement assez simple en python, mais étant une quiche en programmation parallèle j’y ai passé déjà 2 jours de taff

En gros, je construis un dictionnaire qui me sert à représenter un plan 2D (je peux switcher éventuellement à un tableau 2 dimensions étant donné que j’utilise un dictionnaire juste pour pouvoir utiliser des tuples en indice pour stocker mes coordonnées (x,y))

Je passe plusieurs fois sur ce dictionnaire de 5000x5000 entrées (d’où le côté lent de l’exécution) pour faire différents traitements avec des données (en gros des simulations de physique en 2D, mais c’est juste à chaque fois des opérations super simples). j’ai décidé de paralléliser le tout avec le package multiprocessing natif de python en utilisant un ProcessPoolExecutor et en passant mon dictionnaire à mes processus qui s’exécutent en parallèle avec un dict de la classe Manager Sauf que je ne sais pas si ce sont les opérations de lecture, d’écriture ou les deux mais c’est terriblement long (plus même qu’avant parallélisation) et clairement pas viable J’suis sur que ça vient de ça parce que quand je fais les calculs mais que je n’utilise pas ce dictionnaire, juste un dictionnaire dans mon sous-processus (et donc que je n’ai pas accès dans mon main processus à ces résultats) mon programme s’exécute environ 4x plus vite que sans, mais dès que je réutilise le dict du Manager pour récupérer les résultats, on arrive quasiment à un programme 2x moins rapide, puis j’ai vu quelques personnes se plaindre de cette lenteur aussi ci et là

Du coup deux questions, déjà est-ce que si je passais aux listes de la classe Manager j’aurai des chances d’avoir un gain de performances ? (je vais aller vérifier ça de mon côté mais si quelqu’un le sait d’avance) et ensuite quels autres solutions j’aurais pour pouvoir garder cette structure de données qui est assez complexe (un couple (x,y) renvoie à un objet unique qui peut s’étendre ou non sur plusieurs coordonnées donc difficile de faire autrement qu’avec un dict ou une liste de ces objets
Je met pas d’extrait de code parce que je vois pas trop en quoi ça serait cohérent, grosso modo la 1ere partie ou je l’utilisais c’était pour initialiser mon dictionnaire, donc un double for et on fait un grid[y, x] = None, vraiment rien de complexe mais toutes les solutions que j’ai trouvé et qui semblaient donner quelque chose reposaient sur Manager

Merci d’avance!

Merci pour vos réponses !

En gros une case du dictionnaire contient simplement une référence à un objet qui représente une particule, ensuite je simule le déplacement d’un laser sur le plan pour simuler l’interaction entre les deux

du coup je fais un passage en écriture pour placer mes particules, et ensuite uniquement de la lecture, en découpant le passage du laser en ligne, puis en trouvant toutes les particules qui vont être touchées par le laser, et pour les Queue (on parle bien de celle fournies par multiprocessing?) elles étaient vraiment trop lentes pour ça

En effet j’étais vachement vague, en gros ce que je fais c’est ça:
La simulation calcule les coordonnées de chaque point par lequel passe le laser (en comptant la taille du spot du laser du coup)
Elle va chercher dans mon dictionnaire (ou autre du coup) les particules associées à ces points
Et finalement j’appelle une fonction sur cette particule pour calculer l’énergie qu’elle a reçue pour lui assigner un état

Du coup les calculs s’effectuent pas sur le tableau directement, c’est pour ça que j’ai pas trouvé comment utiliser map ou star_map dessus :/

Et pour répondre à Quentin, toutes les cases sont remplies par une référence, la seule optimisation à laquelle j’avais pensé c’était de générer et prendre en compte une particule uniquement si cette dernière est excitée par le laser, mais c’était une optimisation que je comptais faire à la fin, j’avais vraiment sous estimé le nombre de calculs / d’accès en lecture et écriture de structures de données qui allaient être faits c’est ma faute, mais j’vais essayer de suivre tes pistes

Donc j’vais commencer par suivre vos conseils et dégager ce dictionnaire, merci à vous

(Et oui clairement on aurait jamais du utiliser python mais on a plus le temps pour changer de techno la deadline étant dans un mois)

Et pour répondre à Quentin, toutes les cases sont remplies par une référence

Donc comme je disais, prends une simple liste, tant que tu peux l’avoir en entier en mémoire, c’est ce qui sera le plus rapide.

Pour gagner encore en vitesse, tu peux jouer sur la façon dont une coordonnée (x,y) correspond à une case i de la liste. Le truc le plus simple, c’est i = y*width + x, ça correspond à un tableau rempli ligne par ligne.

Mais suivant ta façon de lire et d’écrire, c’est peut-être mieux de faire colonne par colonne, ou en dalles carrées ou rectangulaires. L’idée est que les données que tu dois manipuler ensemble devraient aussi être proches en mémoire, pour aider le cache.

Si je comprends bien, tu aurais peut-être intérêt à organiser une répartition en dalles afin que le rayon laser traverse le moins de jointures possibles. Si les trajectoires sont aléatoires, donc, peut-être des dalles carrées comme compromis.

Il est complètement absurde d’utiliser des listes ou des dictionnaires en Python pour faire des tâches lourdes en calculs. Il faut utiliser des tableaux numpy. C’est la première chose à faire avant même de songer à paralléliser ou quoique ce soit d’autre. La structure de données n’est simplement pas la bonne.

Et même avant d’en arriver aux tableaux qui me semblent logique en soit, il est aussi important de profiler afin de vérifier quel est le goulot d’étranglement du programme exécuté.

Normalement si c’est bien fait, les fonctions sont suffisamment découpées pour qu’on puisse en distinguer les étapes problématiques. Sinon, avec une idée de la chose, on peut isoler cette idée dans une fonction afin de simuler et reproduire le problème.

Mais il est vrai qu’avant de se lancer dans son code, on réfléchi à la structure de données la plus adaptée…

en effet, cependant on n’était pas sensés avoir autant de données c’est pour cela que pour des raisons pratique on avait décidé d’utiliser un dictionnaire pour pouvoir indicer avec des tuples

maintenant tout est avec numpy (j’étais d’ailleurs persuadé que numpy pouvait uniquement gérer les types de base je sais pas pourquoi) mais j’ai un autre problème qui va nécessiter son thread pour lui tout seul, merci pour vos conseils en tous cas!