---

IDEA Setup

---

Environment Assumptions

NASA Ames Research Center (NASA ARC) develops and maintains IDEA. Though IDEA is designed to simplify porting to a wide range of operating systems, IDEA development is currently done exclusively in Linux. If at all possible, we strongly recommend building and running IDEA on systems similar to those used for testing IDEA at NASA ARC. The more closely your system resembles ours, the more readily NASA ARC can help to resolve issues you might have in building and running IDEA. However, if your development environment differs from ours, we would be happy to assist you in porting IDEA to your own platform.

Operating System

IDEA currently builds and operates correctly at NASA ARC under the following operating system versions:

Linux:

• Red Hat 7
• Red Hat 8
• Red Hat 9
• Fedora



Applications

This manual presumes that your system includes a number of software applications that typically ship with Red Hat Linux and other popular Linux varieties.

Compilers:

IDEA currently builds correctly under the following compilers:
• gcc 3.2.2
• gcc 3.2.3
• gcc 3.3.4

Check the presence and version of GCC by typing the following:
% which gcc (should provide a path to the executable)
% gcc --version (should result in one of the versions listed above)


Make Systems:
IDEA builds using:
• GNU Make (e.g. 3.79.1)

Check the presence and version of Make by typing the following:
% which make (should provide a path to the executable)
% make --version (should result in one of the versions listed above)


Archiving:
If you plan on checking out software directly from the IDEA software repository at NASA ARC, you will need CVS:
• Concurrent Versions System (CVS) (e.g. 1.11.16)

Check the presence and version of CVS by typing the following:
% which cvs (should provide a path to the executable)
% cvs --version (should result in one of the versions listed above)


In addition, IDEA presumes that your system also includes the following applications:

Java:

IDEA subcomponents currently operate under Java 1.4.2. Check the presence and version of Java by typing the following:
% which java (should provide a path to the executable)
% java -version (should result in one of the versions listed above)

If you don't have Java, download the latest version of the Java 2 Java Runtime Environment (JRE) from the following website:

http://java.sun.com/j2se/1.4.2/download.html

Follow the installation instructions on the website. The resulting Java executables must be in your PATH environment variable.

A first option is simply to include the Java binary directory at the front of your path. If the Java installation directory takes the form <javapath>/bin (e.g. /home/<username>/j2sdk1.4.2_07/bin), perform the following:

bash	csh
% export PATH=<javapath>/bin:$PATH	% setenv PATH <javapath>/bin:$PATH

Alternatively, wherever you store binaries, create symbolic links to four Java-related executables in the Java installation directory. Again, assuming the Java installation directory takes the form <javapath>/bin (e.g. /home/<username>/j2sdk1.4.2_07/bin), and your binary installation directory takes the form <binpath>/bin (e.g. /home/<username>/bin), perform the following:

% cd <binpath>/bin
% ln -s java <javapath>/bin/java
% ln -s javac <javapath>/bin/javac
% ln -s javah <javapath>/bin/javah
% ln -s jar <javapath>/bin/jar




Next, make sure to include this path in your PATH environment variable:

bash	csh
% export PATH=<binpath>/bin:$PATH	% setenv PATH <binpath>/bin:$PATH

Others:
All other applications required to build and run IDEA are included in the IDEA-ALL distribution, described below.

Getting the Software

There are currently two ways to get IDEA source code. If you are a NASA ARC employee, or have access to NASA ARC computer systems, you can check out a version using CVS. Otherwise, NASA ARC will provide you with a copy of the checkout in a compressed archive format.

Defining a Project Directory

In either case, create a directory within which your IDEA project will reside, for example:
% mkdir /home/username/projects/IDEA



This manual will refer to the above directory as {PROJ_DIR}.

CVS Checkout

To check out IDEA from the NASA ARC IDEA CVS repository, you must have access to the machine wow.arc.nasa.gov, and must receive permission to access the IDEA CVS repository (contact the Code TI Systems Group).

First, add the following environment variables to your environment:

bash	csh
% export CVS_RSH=ssh % export CVSROOT=wow.arc.nasa.gov:/home/cvs/ISG-Repository	% setenv CVS_RSH ssh % setenv CVSROOT wow.arc.nasa.gov:/home/cvs/ISG-Repository

Next, move to the main project directory and check out the software from CVS:

% cd {PROJ_DIR}
% cvs -r <tag name> co IDEA-ALL

where <tag name> refers to the latest approved version tag, as supplied by the NASA ARC IDEA development team. The checkout should result in the creation of the directory {PROJ_DIR}/IDEA-ALL.

Compressed Archive File

The IDEA team will provide you with a file named IDEA-ALL.tar.gz. Copy the file to {PROJ_DIR}, move to that directory, and uncompress and extract the files:
% cp IDEA-ALL.tar.gz {PROJ_DIR}
% cd {PROJ_DIR}
% gunzip IDEA-ALL.tar.gz
% tar -xvf IDEA-ALL.tar

The above operations should result in the creation of the directory {PROJ_DIR}/IDEA-ALL.

IDEA-ALL Contents

The directory resulting from performing the CVS checkout or uncompressing and unloading the IDEA archive file, {PROJ_DIR}/IDEA-ALL, should contain the following:
CameraControl: directory containing files for a sample problem domain.
check: executable used to check whether your system has the minimum set of programs required to build and run IDEA
IDEA-DEV: directory containing the IDEA core source code
Makefile: makefile for the entire IDEA system
NewPlan: directory containing EUROPA 1 source code (used by IDEA for model language translation only)
packages: directory containing external software programs required to run IDEA, including ACE, IPC, Xerces and Jam.
PLASMA: directory containing EUROPA 2 source code (used by IDEA for planning)

Building IDEA

Checking For Required External Programs and Settings

First, you should check to see whether you have all the requisite external programs available on your system. Do this by switching to the IDEA-ALL directory and running the check command:


% cd {PROJ_DIR}/IDEA-ALL
% ./check

The output of a successful run should look similar to the following:

Checking for required software versions:
Found gcc version 3.2.2
Found java version 1.4.2_07
Checking for required environment variables:
OSTYPE is set to linux-gnu


Normal and Fast Mode

IDEA and EUROPA can be built for one of two operational modes: Normal Mode (otherwise known as not-fast) and Fast Mode:


• Normal Mode: Compiles in all error trapping statements, in the form of C++ "assert" calls, enabling far better debugging, but sacrificing performance. As a developer, you'll typically be building in Normal Mode while you develop and debug your models and application-specific modules.
  
  
• Fast Mode: Removes "assert" calls and builds under the "-O3" optimization flag, providing far better performance, at the cost of removing most error checking. Once you're confident with models and application-specific modules, or if tests with your application require the additional performance, you'll build and run under the Fast Mode.



Quick Build and Test

The IDEA-ALL module has the capacity to automatically build all of IDEA and its subcomponents, then run a sample application that controls a simple picture taking process. As a developer, you won't use this approach, but it is a useful means to build all the supporting software and to determine whether or not things are configured and working appropriately.

Simply switch to the IDEA-ALL directory and run make:


% cd {PROJ_DIR}/IDEA-ALL
% make RUN-CAMERA

This will uncompress and build supporting external programs, then build EUROPA and IDEA. It will also parse and build the application modules and model, and run IDEA in a simulated execution. The make command will generate a trace to standard out that looks something like the following:


IDEA Build Trace


If the applications build properly and IDEA executes the sample application, IDEA will furthermore generate a log in the directory {PROJ_DIR}/IDEA-ALL/CameraControl/Model/Logs/nominal/cameracontrol.log that should look like the following:


Camera Control Log



Building for Developers

Environment Setup

No environment variables, aside from those defined earlier in this section, should be necessary to get IDEA to build. The primary makefile should contain all required environment augmentations to enable a build.

Install Options

IDEA provides several command line install options for building:
IDEA Mode:
• FAST=1 (Fast mode; Normal mode is default)

Installation Directories: IDEA defines the installation directories to be:

• ${INSTALL_DIR}/bin (binaries)
• ${INSTALL_DIR}/lib (libraries)
• ${INSTALL_DIR}/include (header files)

with the default value of INSTALL_DIR being {PROJ_DIR}/IDEA-ALL/IDEA-DEV. The following are options to customize these paths:

• INSTALL_DIR=<path>
• INSTALL_BIN_DIR=<path>
• INSTALL_LIB_DIR=<path>
• INSTALL_INCLUDE_DIR=<path>

Running Make

Switch to the IDEA directory and make the software, with any of the above install options:


% cd {PROJ_DIR}/IDEA-ALL
% make IDEA <install-options>

These operations should build IDEA plus all supporting software modules (Jam, IPC, Xerces, ACE).

The following command will delete all of the libraries created in the above build:


% make veryclean

However, the supporting modules (Jam, IPC, Xerces, etc) are stable, rarely require updates, and therefore should only need to be built once for any given platform. IDEA and EUROPA, in contrast, may have more frequent updates in the course of development, and will occasionally need to be rebuilt with the addition of new header files, etc. To destroy only IDEA and EUROPA libraries, do the following:


% cd {PROJ_DIR}/IDEA-ALL/IDEA-DEV
% make clean

Occasionally, a more extreme cleaning is required (TBD conditions). In this case use the following from the IDEA-DEV directory:


% make veryclean

In contrast to the section on Quick Build and Test, the above steps only build IDEA and its support software, but do not build any application-specific modules or application models that would be required to build a full IDEA agent. To move to that level, we direct you to the How to Define a New Domain section and beyond.

Library and Binary Files

Building for one IDEA mode and then the other does not clobber the library and binary files created in the first build. Builds for Normal Mode result in file names:

• xxx_g.o (IDEA libraries)
• xxx_g_pic.o (EUROPA libraries)
• xxx_yy_g (IDEA binaries)

while builds for Fast Mode result in file names:
• xxx_o.o (IDEA libraries)
• xxx_o_pic.o (EUROPA libraries)
• xxx_yy_o (IDEA binaries)

where "xxx" refers to the main file name and "yy" refers to "sh" for shared binaries (dynamically loaded) or "st" for static binaries (statically loaded). The default IDEA build will produce shared objects and binaries.

Troubleshooting

---

IDEA Tutorial Table of Contents Previous: Introduction Next: How to Define a New Domain

---

Contact information © IDEA