Qu'est-ce qu'une fonction trampoline ?

Question

Lors de récentes discussions au travail, quelqu'un a fait référence à une fonction trampoline.

J'ai lu la description sur Wikipédia. Cela suffit pour se faire une idée générale de la fonctionnalité, mais j'aimerais quelque chose de plus concret.

Auriez-vous un petit extrait de code simple qui pourrait illustrer une trampoline?

Answer 1

Dans le monde de Microsoft, les trampolines sont généralement appelés 'thunks'.

Voici une page de "Modern C++ Design" d'Andrei Alexandrescu

---

Answer 2

Voir aussi ce article de blog expliquant l'utilisation des trampolines dans les Extensions Réactives .NET (y compris un exemple de code).

Answer 3

Maintenant que C# a Local Functions, le Bowling Game coding kata peut être élégamment résolu avec un trampoline :

using System.Collections.Generic;
using System.Linq;

class Game
{
    internal static int RollMany(params int[] rs) 
    {
        return Trampoline(1, 0, rs.ToList());

        int Trampoline(int frame, int rsf, IEnumerable rs) =>
              frame == 11             ? rsf
            : rs.Count() == 0         ? rsf
            : rs.First() == 10        ? Trampoline(frame + 1, rsf + rs.Take(3).Sum(), rs.Skip(1))
            : rs.Take(2).Sum() == 10  ? Trampoline(frame + 1, rsf + rs.Take(3).Sum(), rs.Skip(2))
            :                           Trampoline(frame + 1, rsf + rs.Take(2).Sum(), rs.Skip(2));
    }
}

La méthode Game.RollMany est appelée avec un nombre de lancers : généralement 20 lancers s'il n'y a pas de spare ou de strike.

La première ligne appelle immédiatement la fonction trampoline : return Trampoline(1, 0, rs.ToList());. Cette fonction locale traverse récursivement le tableau de lancers. La fonction locale (le trampoline) permet au parcours de commencer avec deux valeurs supplémentaires : commencer avec le frame 1 et le rsf (résultat jusqu'à présent) 0.

À l'intérieur de la fonction locale, il y a un opérateur ternaire qui gère cinq cas :

• La partie se termine au frame 11 : retourne le résultat jusqu'à présent
• La partie se termine s'il n'y a plus de lancers : retourne le résultat jusqu'à présent
• Strike : calcule le score du frame et continue le parcours
• Spare : calcule le score du frame et continue le parcours
• Score normal : calcule le score du frame et continue le parcours

La poursuite du parcours se fait en appelant de nouveau le trampoline, mais maintenant avec des valeurs mises à jour.

Pour plus d'information, recherchez : "tail recursion accumulator". Gardez à l'esprit que le compilateur n'optimise pas la récursion terminale. Donc aussi élégante que cette solution puisse être, elle ne sera probablement pas la plus rapide.

Answer 4

Pour C, un trampoline serait un pointeur de fonction:

size_t (*trampoline_example)(const char *, const char *);
trampoline_example= strcspn;
size_t result_1= trampoline_example("xyzbxz", "abc");

trampoline_example= strspn;
size_t result_2= trampoline_example("xyzbxz", "abc");

Modifier : Des trampolines plus ésotériques seraient générés de manière implicite par le compilateur. Un exemple d'utilisation serait une table de saut. (Bien qu'il existe clairement des trampolines plus compliqués au fur et à mesure que vous commencez à essayer de générer du code compliqué.)

Answer 5

typedef void* (*etat_type)(void);
void* etat1();
void* etat2();
void* etat1() {
  return etat2;
}
void* etat2() {
  return etat1;
}
// ...
etat_type etat = etat1;
while (1) {
  etat = etat();
}
// ...