Programme de la mémoire de la mémoire pour différents interprètes / compilateurs

Question

Voici un extrait du Entrée Wikipedia sur le langage de programmation K:

La petite taille de l'interprète et la syntaxe compacte de la langue permet aux applications k de s'adapter entièrement dans le cache de niveau 1 du processeur.

Qu'est-ce qui rend en particulier les programmes K si petits? Quand on utilise ' opérateur en k, map dans un langage fonctionnel compilé comme Haskell, ou équivalent for Boucle dans un langage impératif compilé comme c, je ne peux pas imaginer l'un ou l'autre des compilateurs générant radicalement Code d'assemblage différent ou que ce qui se passe dans les internes de l'interpréteur sera très différent de for boucle. Y a-t-il quelque chose de spécial en K qui rend son runtime et ses programmes si petits?

Il y a un similaire question sur SO, mais les réponses là ne clarifient essentiellement rien.

Answer 1

Il existe des moyens de générer un code très compact. Par exemple, un http://en.wikipedia.org/wiki/threed_code de Forth et similaire. Il est probable que K soit compilé sous une forme de celui-ci.

Answer 2

Je ne suis pas l'auteur de la déclaration Wikipedia ci-dessus, juste quelqu'un qui utilise beaucoup.

Quant au code, K ne déroule pas les boucles ou apporte d'autres modifications à la structure du programme qui l'augmenterait en taille au-delà de ce que vous attendez. L'interprète exécutable lui-même est minuscule. Et les programmes ont tendance à être petits (mais pas nécessairement). Ce n'est pas l'exécution d'une instruction particulière pour la mappage, etc. qui rend plus probable que le code lui-même exécutera tout dans le cache.

Les programmes K ont tendance à être petits car ils sont un petit bytecode serré en stockage, et leur syntaxe a tendance à produire de très petites quantités de code pour une opération donnée.

Comparez ce programme Java:

int r=0;
for(int i=0; i<100; i++) {
  r+=i;
}

Contre ce programme K pour donner le même résultat:

+/!100

La quantité de code en cours d'exécution est similaire, mais le stockage requis par le programme (encore moins de saisie!) Est beaucoup moins. K est idéal pour ceux qui souffrent de blessures au stress répétitives.

Quant aux données, l'encouragement à travailler sur plusieurs éléments de données avec des instructions uniques a tendance à rendre l'accès séquentiel, d'une manière amicale avec le cache, plutôt que sur un accès aléatoire. Tout cela rend simplement plus probable que le programme sera adapté aux caches.

Mais ce ne sont que des tendances et des meilleures pratiques dans la langue en combinaison avec l'exécutable K lui-même. Si vous liez en grande quantité de code supplémentaire, cas spécial de nombreuses fonctions et randomisez vos indices avant d'accéder à vos données, votre programme sera tout aussi hostile au cache que vous vous y attendez.