From mboxrd@z Thu Jan  1 00:00:00 1970
Received: (from weis@localhost) by pauillac.inria.fr (8.7.6/8.7.3) id RAA16029 for caml-red; Wed, 19 Jul 2000 17:50:03 +0200 (MET DST)
Received: from concorde.inria.fr (concorde.inria.fr [192.93.2.39]) by pauillac.inria.fr (8.7.6/8.7.3) with ESMTP id WAA30623 for <caml-list@pauillac.inria.fr>; Tue, 18 Jul 2000 22:49:38 +0200 (MET DST)
Received: from pauillac.inria.fr (pauillac.inria.fr [128.93.11.35])
	by concorde.inria.fr (8.10.0/8.10.0) with ESMTP id e6IKnX905726;
	Tue, 18 Jul 2000 22:49:33 +0200 (MET DST)
Received: (from xleroy@localhost) by pauillac.inria.fr (8.7.6/8.7.3) id WAA26185; Tue, 18 Jul 2000 22:49:33 +0200 (MET DST)
Message-ID: <20000718224932.21916@pauillac.inria.fr>
Date: Tue, 18 Jul 2000 22:49:32 +0200
From: Xavier Leroy <Xavier.Leroy@inria.fr>
To: =?iso-8859-1?Q?David_Mentr=E9?= <David.Mentre@irisa.fr>
Cc: Jean-Marc EBER <Jean-Marc.Eber@socgen.com>, caml-list <caml-list@inria.fr>
Subject: Re: OCaml on IA-64
References: <023623965C0B8031*/c=FR/admd=ATLAS/prmd=SG/o=INFI/s=EBER/g=JEAN-MARC/@MHS> <20000707215813.37253@pauillac.inria.fr> <wd88zv8eux8.fsf@parate.irisa.fr>
Mime-Version: 1.0
Content-Type: text/plain; charset=us-ascii
X-Mailer: Mutt 0.89.1
In-Reply-To: =?iso-8859-1?Q?=3Cwd88zv8eux8=2Efsf=40parate=2Eirisa=2Efr=3E=3B_from_Dav?=
	=?iso-8859-1?Q?id_Mentr=E9_on_Tue=2C_Jul_11=2C_2000_at_02=3A02=3A59PM_+0?=
	=?iso-8859-1?Q?200?=
Sender: weis@pauillac.inria.fr

> By the way, are there any aspects of Caml, like the functionnal part of
> the language, that allows more easy optimizations specific to IA-64
> architecture (for example definition and use of predicates, use of
> speculation, etc.) compared to usual imperative language like C? And at
> the opposite, are there any Caml features that are difficult to compile
> on such an architecture?

Tricky question.  Nowadays, both OCaml and gcc fail to exploit any of
the advanced features of the IA64, and treat it basically like a
conventional RISC with lots of registers and rather picky scheduling
constraints in basic blocks.

Also, many of the IA64 innovations seem to have been designed with
Fortran in mind (e.g. the loop scheduling support), so it's unclear
whether other languages can really take advantage of them.

This said, I'll venture a guess: it could be that loads and stores can be
scheduled more aggressively in OCaml than in C, because the OCaml type
system offers more non-aliasing information (e.g. stores into
immutable data types are always initializing loads and are guaranteed
not to interfere).  On the other hand, OCaml programs tend to perform
more loads than C programs...

Another guess: for lazy languages like Haskell, predication could
prove very useful to handle the two cases "evaluated already" and "not
evaluated yet" without any branch penalty.

Lots of issues to explore...

- Xavier Leroy