Nommez cette technique (elle peut être appelée 'piggybacking')

Question

Quel est le nom de la méthode/technique suivante (je vais essayer de décrire le mieux possible, un rappel sur "mémoization" est probablement nécessaire pour comprendre pourquoi cette technique peut être très utile):

vous commencez certains calculs asynchrones potentiellement lenghty et vous réalisez qu'un calcul identique a déjà été commencé mais pas encore fait et vous « ferroutage » sur le premier calcul. Ensuite, lorsque le premier calcul se termine, il n'émet pas un mais deux rappels.

Le but est de ne pas démarrer inutilement un deuxième calcul car vous savez qu'il y a déjà un calcul identique en cours d'exécution. Notez que, bien que pas tout à fait différent, je ne cherche pas le cas particulier de la mise en cache que "memoization" est: memoization est quand vous commencez un calcul et trouvez un résultat caché (memoized) de ce même de calcul qui est déjà fait que vous pouvez réutiliser.

Ici, je cherche le nom de la technique qui est un peu similaire à la mémoisation (en ce sens qu'elle peut être utile pour certaines des mêmes raisons que la mémoisation est une technique utile), sauf qu'elle réutilise le résultat du premier calcul même si le premier calcul n'est pas encore fait au moment où vous émettez le deuxième calcul.

J'ai toujours appelé cette technique "piggybacking" mais je ne sais pas si c'est correct.

Je l'ai utilisé plus d'une fois comme une sorte de "mémoization sur les stéroïdes" et c'est très pratique. Je ne sais pas quel est le nom de cette technique (avancée?).

EDIT

Merde, je voulais faire des commentaires sur la réponse de epatel mais il a disparu. La réponse de epatel m'a donné une idée, cette technique pourrait être appelée "memoization paresseux" :)

Answer 1

Sons comme un avenir: http://en.wikipedia.org/wiki/Future_%28programming%29

Answer 2

Sons un peu comme Lazy Evaluation, mais pas exactement ...

Answer 3

Dans certains contextes, j'ai entendu cela appelé "demande de fusion".

Answer 4

Ceci est juste memoization des contrats à terme.

Normal "impatient" memoization fonctionne comme ceci:

f_memo(x): 
    critical_section: 
    if (exists answers(f,x)) 
     return answers(f,x) 
    else 
     a = f(x) 
     answers(f,x) = a 
     return a 

Maintenant, si f (x) retourne terme au lieu des résultats réels, le code ci-dessus fonctionne comme est. Vous obtenez l'effet de ferroutage, à savoir comme ceci:

1. fil d'abord appelle f (3)
2. Il n'y a pas de réponse stockée pour f (3), donc dans la section critique, il y a un appel à f (3) .f (3) est implémenté comme renvoyant un futur, ainsi la 'réponse' est prête immédiatement; 'a' dans le code ci-dessus est défini sur le futur F et le futur F est stocké dans le tableau des réponses
3. Le futur F est retourné comme le "résultat" de l'appel f (3), qui est potentiellement toujours en cours
4. Un autre thread appelle f (3)
5. l'avenir F se trouve de la table, et renvoyée immédiatement
6. maintenant, les deux fils ont poignée pour le résultat du calcul; quand ils essaient de le lire, ils bloquent jusqu'à ce que le calcul soit prêt --- dans le post ce mécanisme de communication a été mentionné comme étant implémenté par un rappel, vraisemblablement dans un contexte où les futurs sont moins communs