Version française
Home     About     Download     Resources     Contact us    
Browse thread
A Question About Types and Inlining
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Nicolas Pouillard <nicolas.pouillard@i...>
Subject: Re: [Caml-list] A Question About Types and Inlining
Hi Jim,

On 12/9/06, Jim Grundy <jim_grundy@ichips.intel.com> wrote:
> Apologies in advance for a naive question...
>
> I'm working on a SAT solver in OCaml.  The solver has various types,
> like three-valued bools, variables, literals.  I have modules that
> encapsulate these types and the operations on them.
>
> Now, as it turns out, all these types are represented as ints, but the
> other modules that use those types don't need to know that - and as a
> matter of taste I'd rather not expose this.
>
> The signatures of these modules currently contain lines like this:
>
> type variable (* = int *)
>
> If I uncomment all instances of (* = int *) and reveal the
> representation to the compiler then I get a ... 36% performance
> improvement in the SAT solver.
>
> I have two questions:
>
> 1/ Is there some way I can reveal this representation to the parts of
> the system that clearly need it for effective optimization, without
> opening this up for general use.
>
> 2/ Failing that, has someone got a pleasant method of doing conditional
> compilation so that I can switch these comments on and off with ease?

I take the second part of your question since the obvious answer is camlp4:

There is an extension called pa_macro that provides conditional compilation.

Alas this extension doesn't work with signatures so the following
example is not (yet) supported:

(* foo.mli *)
IFDEF ABSTRACT THEN
type t
ELSE
type t = int
ENDIF

To address that shortcoming you can write an extension syntax dealing
with some semi-opaque types. Such an extension can allow us to write
that:

(* foo.mli *)
type t = semi opaque int

And have compilation option to set:

# For an abstract version
$ ocamlc -c -pp "camlp4o ./pa_opaque.cmo -abstract" foo.mli

# For a concrete version
$ ocamlc -c -pp "camlp4o ./pa_opaque.cmo -concrete" foo.mli

With this extension:

-----------8<-------------------------------------------------------------------------
(* pa_opaque.ml *)
open Pcaml;;
let abstract = ref true;;
EXTEND
ctyp: [[ LIDENT "semi"; LIDENT "opaque"; t = SELF ->
  if !abstract then <:ctyp< 'abstract >> else t
]];
END;;

Pcaml.add_option "-abstract" (Arg.Set abstract)
  "Use abstract types for semi opaque ones";;
Pcaml.add_option "-concrete" (Arg.Clear abstract)
  "Use concrete types for semi opaque ones";;
-----------8<-------------------------------------------------------------------------


Compiled that way:

$ ocamlc -c -I +camlp4 -pp "camlp4o pa_extend.cmo q_MLast.cmo" pa_opaque.ml

Best regards,

>
> I'm using version 3.09.2 of ocamlopt.
>
> Thanks in advance
>
> Jim
>
>
> --
> Jim Grundy, Research Scientist. Intel Corporation, Strategic CAD Labs
> Mail Stop RA2-451, 2501 NW 229th Ave, Hillsboro, OR 97124-5503, USA
> Phone: +1 971 214-1709   Fax: +1 971 214-1771
> http://www.intel.com/technology/techresearch/people/bios/grundy_j.htm
> Key Fingerprint: 5F8B 8EEC 9355 839C D777  4D42 404A 492A AEF6 15E2
>

-- 
Nicolas Pouillard