Back to SYMPHONY Home Page

Getting Started

Here is a sketch outline of how to get started with SYMPHONY. This is basically the same information contained in the README file that comes with the distribution.

• First unpack the distribution by typing ``tar -xzf SYMPHONY-2.7.tgz''.
• Edit the various path variables in the make file ( SYPHONY-2.7/Makefile) to match where you installed the source code and where the LP libraries and header files reside for each architecture on your network. Other architecture-dependent variables should also be set as required. Be sure to read the comments in the make file to understand what variables have to be set.

Compiling the sequential version

• Type ``make'' in the SYMPHONY root directory. This will first make the SYMPHONY library (sequential version). After this step is completed, you are free to type ``make clean'' and/or delete the $ROOT/obj.* and $ROOT/dep.* directories if you want to save disk space. You should only have to remake the library if you change something in SYMPHONY's internal files.
• After making the libraries, SYMPHONY will compile the user code and then make the executable for the sample application, a vehicle routing and traveling salesman problem solver. The name of the executable will be `` master_tm_lp_cg_cp'', indicating that all modules are contained in a single executable.
• To test the sample program, first get some problem files from http://branchandcut.org/VRP/. Make sure the executable directory is in your path and type "master_tm_lp_cg_cp -F sample.vrp", where sample.vrp is the sample problem file.

Compiling for shared memory

• To compile a shared memory version, obtain an OpenMP compliant compiler, such as Omni. Other options are listed at the OpenMP Web site.
• Set the variable CC to the compiler name in the make file and compile as above.
• Voila, you have a shared memory parallel solver.
• Note that if you have previously compiled the sequential version, then you should first type ``make clean_all'', as this version uses the same compilation directories as the sequential version. With one active subproblem allowed, it should run exactly the same as the sequential version so there is no need to compile both.

Compiling for distributed networks

• You must first obtain and install the Parallel Virtual Machine (PVM) software, available for free from Oak Ridge National Laboratories. See Section 1.6 for more notes on using PVM.
• In the Makefile, be sure to set the COMM_PROTOCOL to PVM. Also, change one or more of COMPILE_IN_TM, COMPILE_IN_LP, COMPILE_IN_CG, and COMPILE_IN_CP, to FALSE, or you will end up with the sequential version. Various combinations of these variables will give you different configurations and different executables. See Section 1.10 for more info on setting them. Also, be sure to set the path variables in the make file appropriately so that make can find the PVM library.
• Type ``make'' in the SYMPHONY root directory to make the distributed libraries. As in Step 1 of the sequential version, you may type ``make clean'' after making the library. It should not have to remade again unless you modify SYMPHONY's internal files.
• After the libraries, all executables requested will be made.
• Make sure there are links from your $PVM_ROOT/bin/$PVM_ARCH/ directory to each of the executables in the Vrp/bin.$REV directory. This is required by PVM.
• Start the PVM daemon by typing ``pvm'' on the command line and then typing ``quit''.
• Run the sample application by typing ``master -F sample.vrp''. The actual executable name may not be `` master'' if COMPILE_IN_TM is set to TRUE. See Section 1.10 for more information on executable names.

This should result in the successful compilation of the sample application. Once you have accomplished this much, you are well on your way to having an application of your own. Don't be daunted by the seemingly endless list of user function that you are about to encounter. Most of them are optional or have default options. If you get lost, consult the source code for the sample application to see how it's done.