[Caml-list] Byte code generation for the Ocaml virtual machine (ZAM)

[Caml-list] Byte code generation for the Ocaml virtual machine (ZAM)

[redfire]

Hello all,

I'm currently doing a student project where I have to generate bytecode
for the caml virtual machine. I convert a subset of the Scheme language.
My main issue concerns the dynamic typing mechanism. My idea is to store
every values I manipulate like this (type, value).
But I have a problem with the generation of the data section. For the
moment, I found on the Internet a snippet using the Obj module but I
don't exactly know what this implies in the rest of the code (especially
Obj.repr). The Obj.repr allows the possibility to mix datas of different
type in the same table. Then I can do an output_value (Pervasives) on it
and my data section seems to be correct.

I have a problem to get back these information. With the snippet using
Obj, I was hoping to get a block structure with field 0 -> type and
field 1 -> value. But it doesn't seem to be the case.

With a piece of code maybe it's going to be clearer.

Example of data : (2, 5). 2 is for the type, so here we suppose that 2
means integer and 5 the value integer.
For the moment, I store Obj.repr (2, 5) in a table (code from the
snippet of the Internet), but it doesn't work.
At generation time, I do a output_value oc t where t is the table
containing all tuples.

So what I'm looking for, is a way to get back a block of size 2 with a
field 0 for the type and then field 1 for the value. Is it possible ?

Thank you for your time ;-)

Cheers.

--
Jeremie Salvucci

Re: [Caml-list] Byte code generation for the Ocaml virtual machine (ZAM)

[Basile Starynkevitch]

On Sun, 01 May 2011 12:10:54 +0200
redfire <jeremie.salvucci@free.fr> wrote:

> Hello all,
> 
> I'm currently doing a student project where I have to generate bytecode
> for the caml virtual machine. I convert a subset of the Scheme language.
> My main issue concerns the dynamic typing mechanism. My idea is to store
> every values I manipulate like this (type, value).

Salut Jérémie, 

je suis très heureux de te lire. Par contre, je n'ai pas compris ton message (alors que je connais bien Ocaml et bien son bytecode). C'est quoi ton but exact? Coder un Scheme en Ocaml?

Amicalement



-- 
Basile STARYNKEVITCH         http://starynkevitch.net/Basile/
email: basile<at>starynkevitch<dot>net mobile: +33 6 8501 2359
8, rue de la Faiencerie, 92340 Bourg La Reine, France
*** opinions {are only mine, sont seulement les miennes} ***

Re: [Caml-list] Byte code generation for the Ocaml virtual machine (ZAM)

[redfire]

Salut Basile,

Je compile un sous ensemble de Scheme vers la ZAM. La machine virtuelle
d'Ocaml n'étant pas typée pour Scheme, je dois implémenter un mécanisme
qui va me permettre de tester les types à l'exécution.

D'après ce que j'ai compris, la machine virtuelle ne prend en compte que
les entiers de base. Le reste est géré par l'intermédiaire de primitives
C. Donc par exemple, si dans le programme source Scheme il est écrit
(display 5), je voulais stocker dans l'environnement global un couple
(2, 5). Le 2 représentant le type integer ici. Comme ça à l'exécution,
je sais que je  dois convertir cet entier en une chaîne de caractères à
l'aide de la primitive C correspondante.
Donc ici, je souhaitais sérialiser (2, 5) dans la zone data (avec le
module Marshall) en espérant récupérer un bloc composé d'au moins deux
champs dont deux d'entre eux seraient, le type et la valeur.
Malheureusement, je ne parviens pas à ce résultat. Je ne récupère que le
5.

En écrivant ce mail, je pense à une autre technique qui consisterait
plutôt à sérialiser seulement la valeur (vu que je ne parviens qu'à
récupérer celle-ci) et à générer le bloc à l'aide de MAKEBLOCK. Mais ça
me ferait modifier pas mal de choses.

Donc mon principal problème concerne la mise en place de ces couples
dans la zone data et leur récupération. Dans le mail précédent,
j'expliquais que j'ai trouvé un exemple sur internet qui sérialisait les
données dans un tableau à l'aide de Obj.repr pour mettre des données de
types différents dans un même tableau. Ensuite il fait un output value
et ça fonctionne. Sauf que ce morceau de code ne travaille que sur des
données de types primitifs et non pas de couples ou autres.

Je souhaite simplement pouvoir stocker un couple et récupérer chacun des
champs. Mais je n'ai pas trouvé de documentation qui explique clairement
et dans le détail comment tout ceci peut-être effectué.

J'espère avoir été un peu plus clair.

Il y a peut-être un moyen beaucoup plus simple de réaliser ceci mais je
ne le connais pas.

Merci à toi ;-)

Amicalement.

--
Jérémie Salvucci

Le dimanche 01 mai 2011 à 12:30 +0200, Basile Starynkevitch a écrit :
> On Sun, 01 May 2011 12:10:54 +0200
> redfire <jeremie.salvucci@free.fr> wrote:
> 
> > Hello all,
> > 
> > I'm currently doing a student project where I have to generate bytecode
> > for the caml virtual machine. I convert a subset of the Scheme language.
> > My main issue concerns the dynamic typing mechanism. My idea is to store
> > every values I manipulate like this (type, value).
> 
> Salut Jérémie, 
> 
> je suis très heureux de te lire. Par contre, je n'ai pas compris ton message (alors que je connais bien Ocaml et bien son bytecode). C'est quoi ton but exact? Coder un Scheme en Ocaml?
> 
> Amicalement
> 
> 
> 

Re: [Caml-list] Byte code generation for the Ocaml virtual machine (ZAM)

[redfire]

Bonjour,

Le dimanche 01 mai 2011 à 15:01 +0200, Guillaume Yziquel a écrit :
> Bonjour.
> 
> Je pense que cela serait une bonne idée que vous soyez plus explicite
> sur ce que vous faites et là où cela ne marche pas. À priori, je ne vois
> pas pourquoi cela ne serait pas possible, au contraire. Mais je me vois
> mal vous répondre sans plus de détails.
> 
> Le Sunday 01 May 2011 à 12:55:07 (+0200), redfire a écrit :
> > Salut Basile,
> > 
> > Je compile un sous ensemble de Scheme vers la ZAM. La machine virtuelle
> > d'Ocaml n'étant pas typée pour Scheme, je dois implémenter un mécanisme
> > qui va me permettre de tester les types à l'exécution.
> > 
> > D'après ce que j'ai compris, la machine virtuelle ne prend en compte que
> > les entiers de base. Le reste est géré par l'intermédiaire de primitives
> > C. Donc par exemple, si dans le programme source Scheme il est écrit
> > (display 5), je voulais stocker dans l'environnement global un couple
> > (2, 5). Le 2 représentant le type integer ici. Comme ça à l'exécution,
> > je sais que je  dois convertir cet entier en une chaîne de caractères à
> > l'aide de la primitive C correspondante.
> > Donc ici, je souhaitais sérialiser (2, 5) dans la zone data (avec le
> > module Marshall) en espérant récupérer un bloc composé d'au moins deux
> > champs dont deux d'entre eux seraient, le type et la valeur.
> > Malheureusement, je ne parviens pas à ce résultat. Je ne récupère que le
> > 5.
> 
> C'est ici que j'aimerais plus de détails.

J'ai choisi de représenter l'ensemble des valeurs manipulées par des
couples (type, valeur). Donc par exemple, si je travaille sur le code
Scheme suivant :

(display 5)

J'ai donc l'entier 5 et la primitive d'affichage de Scheme. Pour
représenter l'entier sur la VM, je le considère comme un couple (2, 5).
Maintenant à l'exécution, je veux que le code généré réalise les actions
suivantes :

- test du type de la valeur
- suivant le type de cette dernière, conversion à l'aide d'une des
primitives d'ocaml (caml_format_int, caml_format_*).
- puis appel de la primitive caml_ml_output.
- on pourrait imaginer un flush.

Pour cela, j'ai choisi d'adopter la stratégie suivante, je place
l'ensemble de mes couples dans l'environnement global (peut-être pas la
meilleure solution mais déjà j'aimerais faire fonctionner quelque
chose). Donc à la compilation, je crée un tableau contenant un ensemble
de couples (type, valeur) que je sérialise à l'aide du module Marshall
directement dans la zone data du fichier contenant le byte code.

Maintenant à l'exécution, imaginons que le couples (2, 5) soit à l'index
18 de l'environnement global. Je réalise un GETGLOBAL 18. Et pour tester
le type j'enchaîne avec un GETFIELD 0, PUSH, CONSTINT <montype>, suivi
d'un EQ. Or la valeur obtenue à l'aide du GETFIELD 0 est un 5 et non un
2.

La façon actuelle de créer ce tableau de couples est la suivante :

table.(18) <- Obj.repr (2, 5) par exemple pour l'exemple ci-dessus
(exemple de code que j'ai trouvé sur Internet sans garantie).

Ce tableau est ensuite écrit à l'aide de output_value de Pervasives.

Est-ce que ceci doit fonctionner et donc je m'y prends mal ailleurs. Ou
ce n'est pas la bonne façon de faire ceci ?

> 
> > En écrivant ce mail, je pense à une autre technique qui consisterait
> > plutôt à sérialiser seulement la valeur (vu que je ne parviens qu'à
> > récupérer celle-ci) et à générer le bloc à l'aide de MAKEBLOCK. Mais ça
> > me ferait modifier pas mal de choses.
> > 
> > Donc mon principal problème concerne la mise en place de ces couples
> > dans la zone data et leur récupération. Dans le mail précédent,
> > j'expliquais que j'ai trouvé un exemple sur internet qui sérialisait les
> > données dans un tableau à l'aide de Obj.repr pour mettre des données de
> > types différents dans un même tableau. Ensuite il fait un output value
> > et ça fonctionne. Sauf que ce morceau de code ne travaille que sur des
> > données de types primitifs et non pas de couples ou autres.
> > 
> > Je souhaite simplement pouvoir stocker un couple et récupérer chacun des
> > champs. Mais je n'ai pas trouvé de documentation qui explique clairement
> > et dans le détail comment tout ceci peut-être effectué.
> > 
> > J'espère avoir été un peu plus clair.
> > 
> > Il y a peut-être un moyen beaucoup plus simple de réaliser ceci mais je
> > ne le connais pas.
> > 
> > Merci à toi ;-)
> > 
> > Amicalement.
> > 
> > --
> > Jérémie Salvucci
> > 
> > Le dimanche 01 mai 2011 à 12:30 +0200, Basile Starynkevitch a écrit :
> > > On Sun, 01 May 2011 12:10:54 +0200
> > > redfire <jeremie.salvucci@free.fr> wrote:
> > > 
> > > > Hello all,
> > > > 
> > > > I'm currently doing a student project where I have to generate bytecode
> > > > for the caml virtual machine. I convert a subset of the Scheme language.
> > > > My main issue concerns the dynamic typing mechanism. My idea is to store
> > > > every values I manipulate like this (type, value).
> > > 
> > > Salut Jérémie, 
> > > 
> > > je suis très heureux de te lire. Par contre, je n'ai pas compris ton message (alors que je connais bien Ocaml et bien son bytecode). C'est quoi ton but exact? Coder un Scheme en Ocaml?
> > > 
> > > Amicalement
> > > 
> > > 
> > > 
> > 
> > 
> > 
> > -- 
> > Caml-list mailing list.  Subscription management and archives:
> > https://sympa-roc.inria.fr/wws/info/caml-list
> > Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> > Bug reports: http://caml.inria.fr/bin/caml-bugs
> > 
> > 
> 

Merci à vous.

--
Jérémie Salvucci

Re: [Caml-list] Byte code generation for the Ocaml virtual machine (ZAM)

[Guillaume Yziquel]

Le Sunday 01 May 2011 à 12:55:07 (+0200), redfire a écrit :
> Salut Basile,
> 
> Je compile un sous ensemble de Scheme vers la ZAM. La machine virtuelle
> d'Ocaml n'étant pas typée pour Scheme, je dois implémenter un mécanisme
> qui va me permettre de tester les types à l'exécution.
> 
> D'après ce que j'ai compris, la machine virtuelle ne prend en compte que
> les entiers de base. Le reste est géré par l'intermédiaire de primitives
> C. Donc par exemple, si dans le programme source Scheme il est écrit
> (display 5), je voulais stocker dans l'environnement global un couple
> (2, 5). Le 2 représentant le type integer ici. Comme ça à l'exécution,
> je sais que je  dois convertir cet entier en une chaîne de caractères à
> l'aide de la primitive C correspondante.
> Donc ici, je souhaitais sérialiser (2, 5) dans la zone data (avec le
> module Marshall) en espérant récupérer un bloc composé d'au moins deux
> champs dont deux d'entre eux seraient, le type et la valeur.
> Malheureusement, je ne parviens pas à ce résultat. Je ne récupère que le
> 5.

yziquel@seldon:~/sandbox/ocaml/bytecode$ cat couple.ml 
let get_type : int * int -> int = function (t, _) -> t 
yziquel@seldon:~/sandbox/ocaml/bytecode$ ocamlc -c -dlambda couple.ml 
(setglobal Couple!
  (let (get_type/1030 (function param/1033 (field 0 param/1033)))
    (makeblock 0 get_type/1030)))
yziquel@seldon:~/sandbox/ocaml/bytecode$ ls
couple.cmi  couple.cmo  couple.ml
yziquel@seldon:~/sandbox/ocaml/bytecode$ ocamldumpobj couple.cmo 
## start of ocaml dump of "couple.cmo"
       0  BRANCH 6
       2  ACC0 
       3  GETFIELD0 
       4  RETURN 1
       6  CLOSURE 0, 2
       9  PUSHACC0 
      10  MAKEBLOCK1 0
      12  POP 1
      14  SETGLOBAL Couple
## end of ocaml dump of "couple.cmo"
yziquel@seldon:~/sandbox/ocaml/bytecode$ 

Ou peut-être plus explicite:

yziquel@seldon:~/sandbox/ocaml/bytecode$ cat couple.ml 
let couple = (2, 5)
let _ = let (t, _) = couple in t
yziquel@seldon:~/sandbox/ocaml/bytecode$ ocamlc -c -dlambda couple.ml
(setglobal Couple!
  (let (couple/1030 [0: 2 5])
    (seq (field 0 couple/1030) (makeblock 0 couple/1030))))
yziquel@seldon:~/sandbox/ocaml/bytecode$ ocamldumpobj couple.cmo
## start of ocaml dump of "couple.cmo"
       0  GETGLOBAL <0>(2, 5)
       2  PUSHACC0 
       3  GETFIELD0 
       4  ACC0 
       5  MAKEBLOCK1 0
       7  POP 1
       9  SETGLOBAL Couple
## end of ocaml dump of "couple.cmo"

Essentiellement, il me semble qu'il s'agit de GETFIELD0. Mais je vous
suggère d'utiliser d'autres valeurs que 2 et 5. En effet, l'entier 2 est
représenté par un 5 dans le bloc puisque 2 * 2 + 1 = 5. Je ne sais pas
comment vous faites pour lire un 5 à la place du 2, mais si c'est via
des fonctions en C, c'est peut-être là votre problème.

> En écrivant ce mail, je pense à une autre technique qui consisterait
> plutôt à sérialiser seulement la valeur (vu que je ne parviens qu'à
> récupérer celle-ci) et à générer le bloc à l'aide de MAKEBLOCK. Mais ça
> me ferait modifier pas mal de choses.
> 
> Donc mon principal problème concerne la mise en place de ces couples
> dans la zone data et leur récupération. Dans le mail précédent,
> j'expliquais que j'ai trouvé un exemple sur internet qui sérialisait les
> données dans un tableau à l'aide de Obj.repr pour mettre des données de
> types différents dans un même tableau. Ensuite il fait un output value
> et ça fonctionne. Sauf que ce morceau de code ne travaille que sur des
> données de types primitifs et non pas de couples ou autres.
> 
> Je souhaite simplement pouvoir stocker un couple et récupérer chacun des
> champs. Mais je n'ai pas trouvé de documentation qui explique clairement
> et dans le détail comment tout ceci peut-être effectué.
> 
> J'espère avoir été un peu plus clair.
> 
> Il y a peut-être un moyen beaucoup plus simple de réaliser ceci mais je
> ne le connais pas.
> 
> Merci à toi ;-)
> 
> Amicalement.
> 
> --
> Jérémie Salvucci
> 
> Le dimanche 01 mai 2011 à 12:30 +0200, Basile Starynkevitch a écrit :
> > On Sun, 01 May 2011 12:10:54 +0200
> > redfire <jeremie.salvucci@free.fr> wrote:
> > 
> > > Hello all,
> > > 
> > > I'm currently doing a student project where I have to generate bytecode
> > > for the caml virtual machine. I convert a subset of the Scheme language.
> > > My main issue concerns the dynamic typing mechanism. My idea is to store
> > > every values I manipulate like this (type, value).
> > 
> > Salut Jérémie, 
> > 
> > je suis très heureux de te lire. Par contre, je n'ai pas compris ton message (alors que je connais bien Ocaml et bien son bytecode). C'est quoi ton but exact? Coder un Scheme en Ocaml?
> > 
> > Amicalement
> > 
> > 
> > 
> 
> 
> 
> -- 
> Caml-list mailing list.  Subscription management and archives:
> https://sympa-roc.inria.fr/wws/info/caml-list
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
> 
> 

-- 
     Guillaume Yziquel