Introduction

The PathScale compilers are supplied with a suite of software that manages
subscriptions. In order to run the PathScale compilers it is necessary for you
to have a valid subscription. A subscription gives you the right to use the
PathScale compilers to obtain the best possible performance from your
software.

There are three types of subscriptions supported by the subscription
management software:

1. Nodelocked, single (named) user
2. Nodelocked, multiple (named) users
3. Floating, multiple (possibly named)
   users on multiple machines

Nodelocked Single User

This subscription type allows a single user to run the compilers on a
single machine. The information needed by PathScale in order to issue a
subscription of this type is:

1. The MAC address of the machine upon
   which the compiler will run
2. The username of the user who will run
   the compiler

The subscription allows the named user to run the compiler an unlimited
number of times on the specified host. The subscription file is tied to the
host and cannot be used on any other host.

If the machine to which the subscription is locked contains multiple active
Ethernet interfaces, the MAC address passed to PathScale must match one of
them. If we lock to an interface that is not marked as UP, then the node
locking will fail.

Nodelocked, Multiple User

This subscription is very similar to the Nodelocked, single user
subscription in that it allows a number of users to run the compiler on a
single machine. Like the single-user case, the list of usernames for the
authorized users is required, along with the MAC address of the host in order
to issue the subscription.

Floating

This is the most flexible of the subscription schemes and is most useful
for a larger group. Like other, commercial, licensing schemes, the floating
subscription scheme allows multiple users to run the compilers on multiple
machines up to the limit of 'seats'. In order to use this subscription scheme,
it is necessary to run a daemon on your network that is accessible from the
machines running the compiler.

The mainstay of the floating subscription model is the concept of a 'seat'.
This is defined to be a unique username and hostname pair. When you buy a
floating subscription, PathScale needs to know how many seats you will
require. The subscription daemon keeps track of the number of seats you have
used at any time and how many are available.

Seats are issued in the form of a 'lease' for a fixed period of time. When
you run the compiler, the daemon will verify that there is a seat available
for you and issue a lease tied to the username of the person running the
compiler and the hostname of the machine upon which the compiler is running.
For the duration of the lease, the username/hostname pair has access to the
compiler to run an unlimited number of times. If a leaseholder runs the
compiler within the lease period, the lease is automatically renewed.

It should be noted that this is different from the traditional licensing
model used by other licensing software. Whereas the PathScale model issues a
user a lease for a period of time, the traditional model is to track the
number of concurrent users, each user blocking until a seat is available.

The subscription daemon uses the following formula to determine if there
are seats available:

numseats = max(users, machines)

For example, if a site has 10 users and 20 machines, and the subscription
specifies that the number of seats is 10, then 10 users can execute on 10 or
less machines.

Like the Nodelocked subscription, the floating subscription daemon is tied
to a single host, specified by the MAC address. This means that the daemon
cannot be run on another host. If this is required, another subscription file
must be generated.

When a user runs the compiler that has a floating subscription, the
compiler must be able to find the daemon. The following algorithm is used:

1. First see if it can find the
   subscription file. It searches for the a file called pscsubscription.xml in
   the following places:
   1. The contents of the environment
      variable PATHSCALE_SUBSCRIPTION_DIR
   2. The user's home directory
   3. The location in which the compiler
      was installed
2. If the subscription file was found,
   look inside it to see if the <daemon/> tag was specified. If so, use this to
   determine the host and port of the server
3. If the subscription file was not
   found, look for the server on the following addresses:
   1. The contents of the environment
      variable PATHSCALE_SUBSCRIPTION
   2. The hostname 'pscsubscriptionserver'
      (if it exists)

The floating subscription deamon runs by default on port TCP/7143, but this
can be changed when the subscription was issued. It is not possible to change
the port number after the subscription file is generated without generating a
new file. If the port number is changed from the default, the compiler must be
told what the new port number is. This is done either by allowing the compiler
to see the subscription file or by specifying the hostname and port in the
PATHSCALE_SUBSCRIPTION environment variable.

 

Proxies

If the subscription daemon is running on a machine that is on the other
side of a firewall from the machines running the compiler, it may be necessary
to use an HTTP proxy to talk to it. This can be achieved by setting the
following environment variables in the shell of the user running the compiler:

HTTP_PROXY_HOST - the hostname of the proxy machine

HTTP_PROXY_PORT - the port upon which the proxy is running.

The compiler will attempt to connect to the daemon directly first before
using the proxy.

 

Running the daemon on a different interface

Occasionally it is necessary to be able
to run the subscription daemon on an ethernet interface other than the default
for the machine. By default, the daemon runs on the IP address returned by
calls to gethostname() and gethostbyname(). If this is not the desired
address, you can change the address in a number of ways:

1. Tell PathScale when you order the
   subscription. We will encode it into the subscription file.
2. Pass the flag -iface n.n.n.n to the 'subserver'
   program when it starts. The value of n.n.n.n is the IP address assigned to
   the interface you want to listen on.

Note that it is important that the MAC address passed to PathScale when the
subscription was issued match the IP address of the interface.

Named and priority users

A floating subscription can be tied to a named set of users. This can be
done in two ways: exclusive and non-exclusive.

• Exclusive users: In this mode, only
  the named users will be granted leases for available seats. No other users
  will be allowed to use the system.
• Non-exclusive users: Like the
  exclusive case, this allows a list of users to be specified. Unlike
  it, however, other users will still be allowed to use the compiler, but with
  a lower priority than those users who are known to the subscription manager.
  If a named (priority) user wishes to gain a lease, a non-priority user may
  lose his lease in preference to the named user. This will only happen if
  there are no available seats and the unnamed user chosen to lose the lease
  will be the one who has the least time to run on the lease.

The priority user scheme allows a core set of users to be specified to be
given the highest priority, but also allows others to use the compiler when
there are available seats not being used by the core users.

The set of named users, and the exclusivity of the set is contained in the
subscription file and can be modified by the administrator to add or remove
users and change the exclusivity.

The subscription file

This file is a plain text file that contains information about the
subscription. It is not supplied on the CD, but is emailed to you after the
relevant information about the subscribed systems is obtained. The file is in
an XML-like format and can be edited by the administrator. Beware that most of
the fields in the file are subject to a checksum and any modification to these
fields will invalidate the subscription.

The following fields are editable by the administrator:

<users value="" exclusive=""/>

This is the list of users and the exclusivity setting. The list of users
is a comma-separated string of usernames (no spaces allowed). The value of
'exclusive' is either "true" or "false".

For example: <users value="dallison,joeb,alice1,bob"
exclusive="false"/>

-<daemon host="" port=""/>

This specifies where the daemon runs. The 'host' is the hostname of the
machine. The 'port' is the TCP port number. Normally you would not edit this
field.

For example: <daemon host="12.4.5.6" port="7146"/>

Depending on the subscription model, the subscription file must be
available to certain components of the subscription software:

• Nodelocked: The file must be readable
  by the user running the compiler.
• Floating: The file must be readable by
  the subscription server (daemon) and possibly the user running the compiler.

In the case of a floating subscription, the file may contain information
about where to locate daemon so it might be useful for the users to be able to
see it.

Environment Variables

The following environment variables are influential.

PATHSCALE_SUBSCRIPTION: Where the daemon is running. This is of
the format addr[:port]. The address is either a hostname or an ip address (n.n.n.n).
The port is optional and defaults to 7143

PATHSCALE_SUBSCRIPTION_DIR: Where the pscsubscription.xml file is.
This specifies the directory containing the file.

HTTP_PROXY_HOST The proxy information

HTTP_PROXY_PORT