トランポリン機能とは何ですか？
職場での最近の議論の中で、誰かがトランポリン機能について言及しました。
Wikipedia の説明を読みました。機能の一般的なアイデアを提供するには十分ですが、もう少し具体的なものが欲しいです。
トランポリンを説明する簡単なコードスニペットはありますか？
ウィキペディアで説明されている「トランポリン」のLISP感覚もあります。
一部のLISP実装で使用されるトランポリンは、サンクを返す関数を繰り返し呼び出すループです。プログラムのすべてのコントロール転送を表現するには、単一のトランポリンで十分です。そのように表現されたプログラムはトランポリンまたは「トランポリンスタイル」です。プログラムをトランポリンスタイルに変換することはトランポリン処理です。トランポリン関数を使用して、スタック指向言語で末尾再帰関数呼び出しを実装できます
Javascriptを使用しており、継続渡しスタイルで単純なフィボナッチ関数を記述したいとします。これを行う理由は、たとえばSchemeをJSに移植したり、サーバー側の関数を呼び出すためにとにかく使用しなければならないCPSを使用したりすることには関係ありません。
だから、最初の試みは
function fibcps(n, c) {
if (n <= 1) {
c(n);
} else {
fibcps(n - 1, function (x) {
fibcps(n - 2, function (y) {
c(x + y)
})
});
}
}
しかし、n = 25 Firefoxで「再帰が多すぎます！」というエラーが表示されます。これがまさにトランポリンが解決する問題（Javascriptでの末尾呼び出しの最適化の欠落）です。関数を（再帰的に）呼び出す代わりに、ループで解釈されるように、その関数を呼び出す命令（サンク）をreturnにします。
function fibt(n, c) {
function trampoline(x) {
while (x && x.func) {
x = x.func.apply(null, x.args);
}
}
function fibtramp(n, c) {
if (n <= 1) {
return {func: c, args: [n]};
} else {
return {
func: fibtramp,
args: [n - 1,
function (x) {
return {
func: fibtramp,
args: [n - 2, function (y) {
return {func: c, args: [x + y]}
}]
}
}
]
}
}
}
trampoline({func: fibtramp, args: [n, c]});
}
さまざまな言語でトランポリンで実装された階乗関数の例をいくつか追加します。
Scala：
sealed trait Bounce[A]
case class Done[A](result: A) extends Bounce[A]
case class Call[A](thunk: () => Bounce[A]) extends Bounce[A]
def trampoline[A](bounce: Bounce[A]): A = bounce match {
case Call(thunk) => trampoline(thunk())
case Done(x) => x
}
def factorial(n: Int, product: BigInt): Bounce[BigInt] = {
if (n <= 2) Done(product)
else Call(() => factorial(n - 1, n * product))
}
object Factorial extends Application {
println(trampoline(factorial(100000, 1)))
}
Java：
import Java.math.BigInteger;
class Trampoline<T>
{
public T get() { return null; }
public Trampoline<T> run() { return null; }
T execute() {
Trampoline<T> trampoline = this;
while (trampoline.get() == null) {
trampoline = trampoline.run();
}
return trampoline.get();
}
}
public class Factorial
{
public static Trampoline<BigInteger> factorial(final int n, final BigInteger product)
{
if(n <= 1) {
return new Trampoline<BigInteger>() { public BigInteger get() { return product; } };
}
else {
return new Trampoline<BigInteger>() {
public Trampoline<BigInteger> run() {
return factorial(n - 1, product.multiply(BigInteger.valueOf(n)));
}
};
}
}
public static void main( String [ ] args )
{
System.out.println(factorial(100000, BigInteger.ONE).execute());
}
}
C（大きな数字を実装しないと不運）：
#include <stdio.h>
typedef struct _trampoline_data {
void(*callback)(struct _trampoline_data*);
void* parameters;
} trampoline_data;
void trampoline(trampoline_data* data) {
while(data->callback != NULL)
data->callback(data);
}
//-----------------------------------------
typedef struct _factorialParameters {
int n;
int product;
} factorialParameters;
void factorial(trampoline_data* data) {
factorialParameters* parameters = (factorialParameters*) data->parameters;
if (parameters->n <= 1) {
data->callback = NULL;
}
else {
parameters->product *= parameters->n;
parameters->n--;
}
}
int main() {
factorialParameters params = {5, 1};
trampoline_data t = {&factorial, ¶ms};
trampoline(&t);
printf("\n%d\n", params.product);
return 0;
}
オンラインゲームのチート対策パッチで使用した例を紹介します。
変更のためにゲームによってロードされていたすべてのファイルをスキャンできる必要がありました。そのため、これを実現するための最も堅牢な方法は、CreateFileAにトランポリンを使用することでした。したがって、ゲームの起動時にGetProcAddressを使用してCreateFileAのアドレスを検索し、関数の最初の数バイトを変更して、独自の「トランポリン」関数にジャンプするアセンブリコードを挿入します。次に、jmpコードの後にCreateFileの次の場所に戻ります。確実に実行できるようにするのはそれより少し難しいですが、基本的な概念は、ある関数をフックし、強制的に別の関数にリダイレクトしてから元の関数にジャンプすることです。
編集：Microsoftには、この種のフレームワークがあります。呼ばれる 迂回
ネストされた関数の例を次に示します。
#include <stdlib.h>
#include <string.h>
/* sort an array, starting at address `base`,
* containing `nmemb` members, separated by `size`,
* comparing on the first `nbytes` only. */
void sort_bytes(void *base, size_t nmemb, size_t size, size_t nbytes) {
int compar(const void *a, const void *b) {
return memcmp(a, b, nbytes);
}
qsort(base, nmemb, size, compar);
}
comparは、sort_bytes呼び出し中にのみ存在するnbytesを使用するため、外部関数にはできません。一部のアーキテクチャでは、小さなスタブ関数（トランポリン）が実行時に生成され、sort_bytesのcurrent呼び出しのスタック位置が含まれます。呼び出されると、comparコードにジャンプして、そのアドレスを渡します。
この混乱はPowerPCのようなアーキテクチャでは必要ありません。PowerPCでは、ABIは、関数ポインターが実際に「ファットポインター」、実行可能コードへのポインターとデータへの別のポインターの両方を含む構造であることを指定します。ただし、x86では、関数ポインターは単なるポインターです。
現在、Schemeインタープリターにテールコールの最適化を実装する方法を実験しています。そのため、現時点では、トランポリンが実現可能かどうかを把握しようとしています。
私が理解しているように、それは基本的にトランポリン関数によって実行される一連の関数呼び出しです。各関数はサンクと呼ばれ、プログラムが終了するまで（空の継続）計算の次のステップを返します。
これは、トランポリンの理解を深めるために書いた最初のコードです。
#include <stdio.h>
typedef void *(*CONTINUATION)(int);
void trampoline(CONTINUATION cont)
{
int counter = 0;
CONTINUATION currentCont = cont;
while (currentCont != NULL) {
currentCont = (CONTINUATION) currentCont(counter);
counter++;
}
printf("got off the trampoline - happy happy joy joy !\n");
}
void *thunk3(int param)
{
printf("*boing* last thunk\n");
return NULL;
}
void *thunk2(int param)
{
printf("*boing* thunk 2\n");
return thunk3;
}
void *thunk1(int param)
{
printf("*boing* thunk 1\n");
return thunk2;
}
int main(int argc, char **argv)
{
trampoline(thunk1);
}
結果：
meincompi $ ./trampoline
*boing* thunk 1
*boing* thunk 2
*boing* last thunk
got off the trampoline - happy happy joy joy !
Cの場合、トランポリンは関数ポインターになります。
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");
編集：より難解なトランポリンは、コンパイラによって暗黙的に生成されます。そのような用途の1つは、ジャンプテーブルです。 （明らかに、より複雑なものもありますが、複雑なコードを生成しようとすると、さらに下に向かっていきます。）