Version française
Home     About     Download     Resources     Contact us    
Browse thread
ocamlbuild & deps
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Romain Bardou <bardou@l...>
Subject: Re: [Caml-list] ocamlbuild & deps
Daniel Bünzli wrote:
> 
> Le 20 févr. 09 à 16:39, Romain Bardou a écrit :
> 
>> I think there is a difference. It is indeed an optimization issue but 
>> not at the level of Ocamlbuild itself : it is as the level of your 
>> compilation process. If A *dynamically* depends on B, and your whole 
>> project (say, 10 hours of compilation) depends on A, but you have no 
>> way to build B, then Ocamlbuild will start to compile your project 
>> until it finds out that A cannot be built (maybe several hours later). 
>> If B had been put as a ~dep, then Ocamlbuild would not even had 
>> started building the project in the first place, saving you a lot of 
>> time.
> 
> Heu no. If B cannot be built then the compilation of A stops and the 
> compilation of your project stops.
> 
> It is however true that if A has a dependency on a heavy C in parallel 
> to B you'll have to wait for the end of C. But even in this case, it's 
> just a matter of calling 'build' with B and C in a sensible order (and 
> not in parallel).

Ok I think I did not explain correctly. Let's say that :
- A dynamically depends on B
- A depends on C
- B cannot be built
Now if I try to build A, C will be built, then the rule to build A will 
be applied and the dependency on B will be discovered. But B cannot be 
built so the compilation fails.

Now if the compilation of C takes 10 hours, you will have to wait 10 
hours no matter what. "Damn, I waited 10 hours just to discover that it 
cannot compile!" If the dependency on B was not dynamic, C would not 
have been built at all.

So, there is indeed a difference between dynamic and static 
dependencies, with or without parallelism. In fact, dynamic dependencies 
also tend to break parallelism as dynamic dependencies cannot be built 
at the same time as static dependencies. In my example, C and B cannot 
be built in parallel. This is another difference.

You cannot, in general, run the rule to discover dynamic dependencies 
before building static dependencies. Indeed, what if the rule needs to 
read one of the static dependencies to discover other dependencies?

-- 
Romain Bardou