To compile an IL program, in this example, sample.c++, use the following command line:

# cc -g sample.c++ -o sample -lil 

By default, the *.so libraries are used to link your programs, however, you must link to the IL library itself.

In general, you should not link to the static, *.a, libraries unless you want to keep your application in one complete binary. If you do choose to use the static libraries, use the following command to compile your program:

# cc -g sample.c++ -o sample /usr/lib/libil.a  /usr/lib/libifl.a -lil     -lm -lGL -IX11

If you link to the static libraries, include the IL library, the GL shared library, the X Window library, the math library, and the C++ library.

# Makefile for IL test programs
SHELL = /bin/sh
# If you want to debug,turn on the “-g” option.
FLAGS = -g
MAINS= sample.c++
OBJS = ${FILES:.c++=.o}
PROGS = ${MAINS:.c++=}
LIBS = -lil
.c++:
        CC $(FLAGS) $< -o $@ $(LIBS)
.c++.o:
        CC $(FLAGS) -c $<
clean:
        rm -rf $(OBJS) $(PROGS)
        rm -rf core

Link your C program to the libcil.so library, the C version of the IL. For example, to compile a C program called ctest.c, use this line:

# cc -g ctest.c -o carprot -lcil 

IL is compatible with ANSI C. To use the older, pre-ANSI dialect, add –cckr to the command line. Ignore any warnings generated during compilation.

Refer to the C reference page for more information about the C compilers.

# A very simple Makefile for IL test programs
SHELL = /bin/sh
FLAGS = -g 
CMAINS = csample.c
COBJS = ${CMAINS:.c=.o}
CPROGS = ${CMAINS:.c=}
CLIBS = -lcil 
.c:
    cc $(FLAGS) $< -o $@ $(CLIBS)
clean:
    rm -rf $(COBJS) 
    rm -rf core
clobber: clean
    rm $(CPROGS)

You can use the environment variable IL_CACHE_FRACTION to specify the size of the IL image data cache. The default size is 30% of available user memory. For example, you could set the cache size to 20% of available user memory by issuing the following command prior to running an IL-based application:

% setenv IL_CACHE_FRACTION .2

Alternatively, you can use the environment variable IL_CACHE_SIZE to set the size of the cache in bytes. For example, you could set the cache size to 4 million bytes by issuing the following command prior to running an IL-based application:

% setenv IL_CACHE_SIZE 4000000

The IL_CACHE_SIZE variable takes precedence over IL_CACHE_FRACTION if both are set.

You can use the environment variable IL_HW_ACCELERATE to override the default behavior of using the graphics hardware to perform processing whenever possible. For example, you can disable the hardware acceleration feature of IL by issuing the following command prior to running an IL based application:

% setenv IL_HW_ACCELERATE 0

You might turn off hardware acceleration when debugging operators that are accelerated by the hardware.

When you open a display using IL, you first use the X call, XOpenDisplay(), to return a pointer to the display device. The return value is then passed into ilDisplay to open a window to display an image. You can use IL_HW_DISPLAY to set the value of the display which the return value of XOpenDisplay() points to.

The rendering machine returned by glGetString(GL_RENDERER) is generally the machine you are using. You can override the value returned by glGetString(), however, by setting the IL_HW_RENDERER value. For example, you might be running on an InfiniteReality but want to see what the display would be like on an Impact. In this case, you would set IL_HW_RENDERER to Impact.

---

Caution: Make sure your machine supports the platform you are setting IL_HW_RENDERER to.

---

You can use the IL_MONITOR environment variable to turn on the IL Monitor. The IL Monitor logs an entry wherever one of the following events occurs:

If you want a less-complete level of monitoring is needed, or you need to capture a log of the operations, you can use any combination of the following environment variables:

If you set IL_MONITOR_CACHE to 1, a log entry is generated each time the cache is used, for example:

Page (0,0,0,0) loading in File(0x1000a858)
Page (0,32,0,0) loading in File(0x1000a858)
Page (253,29,0,0) loading in Nop(0x100c8108)

If you set IL_MONITOR_COMPACTION to 1, a log entry is generated each time the cache is compacted, for example:

Compaction reclaimed 144K.
Compaction reclaimed 0K.
Compaction reclaimed 160K.
Compaction reclaimed 144K.
Compaction reclaimed 0K.
Compaction reclaimed 64K.
Compaction reclaimed 176K.
Compaction reclaimed 0K.
Compaction reclaimed 0K.

If you set IL_MONITOR_RESET to 1, a log entry is generated each time an operator is reset, for example:

(brandt@chaos:tests) convrz
File(0x1000a858) initialized
Convolve(0x1000db98) initialized
Rotate/Zoom(0x1000e1a0) initialized
X Window(0x100813f0) initialized
PBuffer(0x10099668) initialized
X Window(0x100ad9a8) initialized
X Window(0x100ad9a8) altered
View(0x100a3218) initialized
X Window(0x100ad9a8) altered
OpenGL Hardware Pass(0x100c1088) initialized
OpenGL Hardware Pass(0x100c1870) initialized
OpenGL Hardware Pass(0x100c1870) altered
Pixel Cache(0x100c2058) initialized

If you set IL_MONITOR_LOCKS to 1, a log of lock creations and destructions is generated. Additionally, at program exit, any remaining locks are displayed. For locks that are created, a short message is printed with the name of the lock. The name consists of the address of the lock optionally followed by a parenthetical comment describing what the lock is used for, for example:

Created lock 4001fa0 (ilMpNode cache)
Created lock 4002070 (ilMpParkedGroup cache)
Created lock 4002140 (ilMpPool cache)
Created lock 4002210 (ilLink mutex)
Created lock 40022e0 (ilImage evalLock)
Created lock 40023b0 (ilLink mutex)

For the destruction of locks as they exit, the name of the lock and its metering information are displayed. The metering information measures such things as how many attempts were made to acquire the lock, how many of those attempts were successful, and how many times the software was forced to start spinning on the lock.

You can use the environment variables IL_COMPUTE_THREADS and IL_READ_THREADS to specify the number of compute threads and file read threads used by each processor. By default, one compute thread is created for each processor on the host system (including the user's thread), and one read thread is created to perform disk I/O in the background. For example, you can disable all multi-processing features in IL by issuing the following commands prior to running an IL-based application:

% setenv IL_COMPUTE_THREADS 0
% setenv IL_READ_THREADS 0

You can set the size of the arena used to allocate spin-locks and semaphores for multi-processing control with the IL_MP_ARENA_SIZE variable. You might set this variable if, for example, you create a large number of objects derived from ilLink.

By default, IL allows up to forty threads to share multi-processing arenas. If you need more, you can set the IL_ARENA_MAXUSERS environment variable to a larger value.