Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
James Kanze writes:Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
De mémoire,
il y a des interruptions quand c'est utilisé pour
de l'indexage. C'est à cette architecture que je faisais
allusion aussi. Mais j'avais oublié que c'était une machine à
tag (en plus des 48 bits de données, il y a quelques bits de
tag) et un tag est prévu pour les données non initialisées,
avec interruption si utilisation.
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
James Kanze <james.ka...@gmail.com> writes:
Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
De mémoire,
il y a des interruptions quand c'est utilisé pour
de l'indexage. C'est à cette architecture que je faisais
allusion aussi. Mais j'avais oublié que c'était une machine à
tag (en plus des 48 bits de données, il y a quelques bits de
tag) et un tag est prévu pour les données non initialisées,
avec interruption si utilisation.
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
James Kanze writes:Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
De mémoire,
il y a des interruptions quand c'est utilisé pour
de l'indexage. C'est à cette architecture que je faisais
allusion aussi. Mais j'avais oublié que c'était une machine à
tag (en plus des 48 bits de données, il y a quelques bits de
tag) et un tag est prévu pour les données non initialisées,
avec interruption si utilisation.
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
même dans ce cas je n'arrive pas à imaginer une valeur spéciale faisant
traper l'injecteur.
As-tu lu le premier article de Jean-Marc Bourguet dans ce fil ?
<cit.>
il y a eu une machine n'ayant que des nombres en virgule flottante, mais
où certaines opérations trappaient si une donnée n'était pas entière
</cit.>
même dans ce cas je n'arrive pas à imaginer une valeur spéciale faisant
traper l'injecteur.
As-tu lu le premier article de Jean-Marc Bourguet dans ce fil ?
<cit.>
il y a eu une machine n'ayant que des nombres en virgule flottante, mais
où certaines opérations trappaient si une donnée n'était pas entière
</cit.>
même dans ce cas je n'arrive pas à imaginer une valeur spéciale faisant
traper l'injecteur.
As-tu lu le premier article de Jean-Marc Bourguet dans ce fil ?
<cit.>
il y a eu une machine n'ayant que des nombres en virgule flottante, mais
où certaines opérations trappaient si une donnée n'était pas entière
</cit.>
lorsqu'elle est lue, or pour que le code: "int x; cout << x;"
soit lu en mémoire et fourni au CPU, il faut qu'il ait été
écrit dans cette mémoire,
Où ça ?
Tu prétends que c'est impossible ? Est-ce que tu peux te
mettre dans la tête que je parle ici d'expérience. [...]
lorsqu'elle est lue, or pour que le code: "int x; cout << x;"
soit lu en mémoire et fourni au CPU, il faut qu'il ait été
écrit dans cette mémoire,
Où ça ?
Tu prétends que c'est impossible ? Est-ce que tu peux te
mettre dans la tête que je parle ici d'expérience. [...]
lorsqu'elle est lue, or pour que le code: "int x; cout << x;"
soit lu en mémoire et fourni au CPU, il faut qu'il ait été
écrit dans cette mémoire,
Où ça ?
Tu prétends que c'est impossible ? Est-ce que tu peux te
mettre dans la tête que je parle ici d'expérience. [...]
On Feb 29, 7:25 pm, Jean-Marc Bourguet wrote:James Kanze writes:Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
De mémoire,
Tu l'as réelement programmé.
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Au moins, Sperry fabriquait les ordinateurs bien avant Burroughs.
Et quant à « en service », je ne sais pas. Ça fait quelque années
maintenant qu'elle a disparu du catalogue d'Unisys.
On Feb 29, 7:25 pm, Jean-Marc Bourguet <j...@bourguet.org> wrote:
James Kanze <james.ka...@gmail.com> writes:
Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
De mémoire,
Tu l'as réelement programmé.
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Au moins, Sperry fabriquait les ordinateurs bien avant Burroughs.
Et quant à « en service », je ne sais pas. Ça fait quelque années
maintenant qu'elle a disparu du catalogue d'Unisys.
On Feb 29, 7:25 pm, Jean-Marc Bourguet wrote:James Kanze writes:Comme j'ai déjà dit ailleurs, j'ai réelement vu le cas où lire
de la mémoire qu'on n'avait jamais écrite pourrait provoquer un
plantage. Mais dans ce cas-là, il suffisait d'y avoir écrit une
fois, depuis la mise sous tension du système. En revanche, il y
avait bien les anciens processeurs de Burroughs/Unisys, qui
avait une architecture tagguée. En particulier, un entier
n'était qu'un virgule flottant avec le champs exposant à 0
(c-à-d 48 bits, avec 8 bits obligatoirement à 0, et magnitude
signée, en plus). Il n'y avait qu'une seule instruction add, par
exemple, qui fonctionnait à la fois pour les flottants et les
entiers, selon les valeurs qu'on lui donnait. Je ne sais pas ce
qui passait si tu mettais des bits d'un flottant dans une
variable de type entier en C, mais ça m'étonnerait que ce soit
quelque chose de bien prévisible.
De mémoire,
Tu l'as réelement programmé.
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Au moins, Sperry fabriquait les ordinateurs bien avant Burroughs.
Et quant à « en service », je ne sais pas. Ça fait quelque années
maintenant qu'elle a disparu du catalogue d'Unisys.
James Kanze writes:C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Mise en service du B5000 en 1961, de la série 1100 d'Univac en 1962.
Au moins, Sperry fabriquait les ordinateurs bien avant Burroughs.
Exact.Et quant à « en service », je ne sais pas. Ça fait quelque
années maintenant qu'elle a disparu du catalogue d'Unisys.
Sur leur page web, tu prends mainframe et tu as accès aux MCP
Mainframes (qui doivent être les descendants du B5000) et aux
OS2200 Mainframes (qui doivent être les descendants de
l'univac 1100). J'ai pas eu le temps de fouiller pour
confirmer, leur site est mal fait si on cherche des détails
techniques.
James Kanze <james.ka...@gmail.com> writes:
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Mise en service du B5000 en 1961, de la série 1100 d'Univac en 1962.
Au moins, Sperry fabriquait les ordinateurs bien avant Burroughs.
Exact.
Et quant à « en service », je ne sais pas. Ça fait quelque
années maintenant qu'elle a disparu du catalogue d'Unisys.
Sur leur page web, tu prends mainframe et tu as accès aux MCP
Mainframes (qui doivent être les descendants du B5000) et aux
OS2200 Mainframes (qui doivent être les descendants de
l'univac 1100). J'ai pas eu le temps de fouiller pour
confirmer, leur site est mal fait si on cherche des détails
techniques.
James Kanze writes:C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Mise en service du B5000 en 1961, de la série 1100 d'Univac en 1962.
Au moins, Sperry fabriquait les ordinateurs bien avant Burroughs.
Exact.Et quant à « en service », je ne sais pas. Ça fait quelque
années maintenant qu'elle a disparu du catalogue d'Unisys.
Sur leur page web, tu prends mainframe et tu as accès aux MCP
Mainframes (qui doivent être les descendants du B5000) et aux
OS2200 Mainframes (qui doivent être les descendants de
l'univac 1100). J'ai pas eu le temps de fouiller pour
confirmer, leur site est mal fait si on cherche des détails
techniques.
On 1 mar, 14:52, Jean-Marc Bourguet wrote:
En effet. Je ne faisais que répéter ce que j'ai entendu
(j'oublie même où). Mais en cherchant, j'en ai trouvé une « C
Programming Reference Manual »,
On 1 mar, 14:52, Jean-Marc Bourguet <j...@bourguet.org> wrote:
En effet. Je ne faisais que répéter ce que j'ai entendu
(j'oublie même où). Mais en cherchant, j'en ai trouvé une « C
Programming Reference Manual »,
On 1 mar, 14:52, Jean-Marc Bourguet wrote:
En effet. Je ne faisais que répéter ce que j'ai entendu
(j'oublie même où). Mais en cherchant, j'en ai trouvé une « C
Programming Reference Manual »,
On 1 mar, 14:52, Jean-Marc Bourguet wrote:James Kanze writes:C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Mise en service du B5000 en 1961, de la série 1100 d'Univac en 1962.
La question, évidemment, c'est : est-ce que la série 1100
d'Univac n'est qu'une prologation d'une architecture antérieur ?
Mais à vrai dire, il n'y a pas de raisons de le supposer, étant
donner la façon que les ordinateurs étaient développés alors.
Enfin, pour ceux qui s'y intéressent, j'ai trouvé cette documentation, et
un tas d'autres documentations, à
http://public.support.unisys.com/common/epa/documentationlibraries.aspx.
(Et en passant, il y a encore des manuals d'Algol. Je rappelle que le
language de programmation préféré dans cet environement, c'était bien
l'Algol.)
Si j'ai bien compris la site, dans les produits haut de gamme,
c'est réelement implémenté dans le hardward ; dans les produits
bas de gamme, c'est plutôt émulé par une machine virtuelle.
On 1 mar, 14:52, Jean-Marc Bourguet <j...@bourguet.org> wrote:
James Kanze <james.ka...@gmail.com> writes:
C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Mise en service du B5000 en 1961, de la série 1100 d'Univac en 1962.
La question, évidemment, c'est : est-ce que la série 1100
d'Univac n'est qu'une prologation d'une architecture antérieur ?
Mais à vrai dire, il n'y a pas de raisons de le supposer, étant
donner la façon que les ordinateurs étaient développés alors.
Enfin, pour ceux qui s'y intéressent, j'ai trouvé cette documentation, et
un tas d'autres documentations, à
http://public.support.unisys.com/common/epa/documentationlibraries.aspx.
(Et en passant, il y a encore des manuals d'Algol. Je rappelle que le
language de programmation préféré dans cet environement, c'était bien
l'Algol.)
Si j'ai bien compris la site, dans les produits haut de gamme,
c'est réelement implémenté dans le hardward ; dans les produits
bas de gamme, c'est plutôt émulé par une machine virtuelle.
On 1 mar, 14:52, Jean-Marc Bourguet wrote:James Kanze writes:C'est la plus vieille architecture encore en service. Les
suivantes sont celle de Sperry (aussi chez Unisys) et IBM 360.
Je crois que celle de Sperry est encore plus ancienne.
Mise en service du B5000 en 1961, de la série 1100 d'Univac en 1962.
La question, évidemment, c'est : est-ce que la série 1100
d'Univac n'est qu'une prologation d'une architecture antérieur ?
Mais à vrai dire, il n'y a pas de raisons de le supposer, étant
donner la façon que les ordinateurs étaient développés alors.
Enfin, pour ceux qui s'y intéressent, j'ai trouvé cette documentation, et
un tas d'autres documentations, à
http://public.support.unisys.com/common/epa/documentationlibraries.aspx.
(Et en passant, il y a encore des manuals d'Algol. Je rappelle que le
language de programmation préféré dans cet environement, c'était bien
l'Algol.)
Si j'ai bien compris la site, dans les produits haut de gamme,
c'est réelement implémenté dans le hardward ; dans les produits
bas de gamme, c'est plutôt émulé par une machine virtuelle.
<cit.>
il y a eu une machine n'ayant que des nombres en virgule flottante, mais
où certaines opérations trappaient si une donnée n'était pas entière
</cit.>
?!??
il y a eu une époque où les hommes vivaient dans des cavernes ...
écrire du code sur un PC devrait être interdit car incompatble
avec les moyens de cette époque ?
<cit.>
il y a eu une machine n'ayant que des nombres en virgule flottante, mais
où certaines opérations trappaient si une donnée n'était pas entière
</cit.>
?!??
il y a eu une époque où les hommes vivaient dans des cavernes ...
écrire du code sur un PC devrait être interdit car incompatble
avec les moyens de cette époque ?
<cit.>
il y a eu une machine n'ayant que des nombres en virgule flottante, mais
où certaines opérations trappaient si une donnée n'était pas entière
</cit.>
?!??
il y a eu une époque où les hommes vivaient dans des cavernes ...
écrire du code sur un PC devrait être interdit car incompatble
avec les moyens de cette époque ?
Mais bon, comme d'habitude tu n'es là que pour troller et j'ai encore
marché dedans...
Mais bon, comme d'habitude tu n'es là que pour troller et j'ai encore
marché dedans...
Mais bon, comme d'habitude tu n'es là que pour troller et j'ai encore
marché dedans...
