Lahey Licensing of Fortran compiler for Linux - in detail ;-)

[Bob Drzyzgula]

On Tue, Jan 21, 2003 at 01:16:47PM -0500, John Burton wrote:
> 
> You misinterpreted the question, or perhaps I didn't phrase it clearly 
> enough. Yes, they add value with the compiler. Yes, you should pay for 
> the license to use the compiler. The question concerns *running* the 
> program that you have compiled using their compiler (runtime vs. compile 
> time)
> 
> I have paid for the compiler. I compile my code with their compiler. 
> This is fine. Now I run the binary code I just compiled. Lahey requires 
> a license for running the program, not just compiling it.
> 
> Example - I have a cluster with 48 CPUs. I compile a FORTRAN program 
> with > 100,000 LOC. Okay, I compile & run it on the cluster, everything 
> is fine under Lahey's 5 to 64 CPU license. I find that the combination 
> of 48 CPUs and Lahey's compiler is not enough to provide the throughput 
> I need (poor benchmarks, under estimating data rates, whatever). I need 
> to add 48 more CPUs. Now I *cannot* legally run my code on my cluster 
> because it violates Lahey's runtime license. Now I need to get a new 
> license.

I'm sorry, I still don't see this. This isn't a runtime
license, it is a code generation license; it is a
license to generate code that will run on a particular
size cluster. If it was a runtime license, you'd have
to license *each* cluster on which the code will run.

In effect, this is more or less like a cross-compiler with
multiple, optional back ends. You generate your code on a
workstation but run it on a target cluster, and the size
of the target determines the price to you to generate the
code. It may in fact be the case that the code generated is
not physically any different from one back end to another,
but it is legally different and that's all that matters.
Such target-sensitive pricing is very common, if not
perfectly standard, in the world of commercial development
tools.

In the case where you are generating code for internal
use on a single cluster, this may *feel* to you like a
runtime license, but it isn't a runtime license in the
conventional, industry SOP sense of the phrase, and no
amount of calling it that will change the fact that it
is *not* a runtime license.

You very clearly make the case that a larger cluster can
have greater value than a smaller cluster; you cite an
example wherein a 48-node cluster won't solve your problem
but a 96-node cluster will. Thus, code that will run on a
larger cluster also has greater value than code that is
limited to a smaller cluster. So why is not not fair to
ask you to pay more for the right to generate code which
has greater value?

> Another Example - My development cluster has 32 nodes. I compile and run 
> code with no problems. I have a production cluster with 256 nodes. Lahey 
> says I can distribute my code to an unlimited number of clusters, but I 
> can't run it on my production cluster without a new license.

Are you compiling the production code on the development
cluster or the production cluster? If you are doing all
the compiling on the development cluster, it sounds like
you never should have purchased a license for the lesser
version of the compiler -- you should license the version
of the compiler that generates code for the ultimate
target.  If, on the other hand, development binaries stay
on the development system and runtime binaries for the
production target are compiled on a server that is part
of the production target, then I would guess that you only
need to buy the lesser license for the development system.
If you then need to move the production code to a yet-larger
cluster, then yes, you'd need a compiler that will generate
code for that larger cluster.

Think of it this way: Suppose that Lahey sold compilers
for both X86 and Alpha, and you licensed the X86 compiler
for development. But then, when you go to production,
you decide to use the code on an Alpha cluster. Would you
then expect that you could generate the Alpha code at
no additional charge? I wouldn't. This is in effect what
Lehey is saying: that for the purposes of their compiler,
a 256-node cluster is a *different thing* than a 32-node
cluster (actually, it's a little more favorable than that --
obviously the 256-node cluster code can run on the 32-node
cluster).

Clearly you don't have to see things that way, but in
that event your only real recourse, I would think would
be to find another compiler vendor that has pricing more
to your liking.

--Bob Drzyzgula