Revised 2006-09-05 DMB

Return to the Index

# Directory and File Structure

This document contains a guide to the files present in Avida, and where they are located.

## Filenames

Source code files in Avida follow a standard naming convention. The C++ core, in general, maintains one class per header/source file pair. The file name should exactly match the class that it defines. All header files use `.h` and all source files use `.cc` as their respective file extensions.

When you compile a program in C++, it goes through a compilation phase and then a link phase. The compilation phase takes each source (`.cc`) file and compiles it independently into an object (`.o`) file. In the link phase, all of these compiled object files are linked together into a single executable (such as `avida`).

Since the bodies of the methods are only in the source files, they only need to be compiled once into a single object file. If you place a function body in the header file it will get compiled again each time another class includes that header. Since a header will often be included because only one or two methods from a class are required, this can increase compile time dramatically -- a function will be compiled as long as its body is included, even if the method is never directly called within the object file being created.

For example: The cOrganism object is declared in the file `cOrganism.h` and fully defined in `cOrganism.cc`. When this file is compiled, it creates the object file `cOrganism.o`. Both the cPopulation class (`cPopulation.cc`) and the cTestCPU class (`cTestCPU.cc`) use the cOrganism object. Since the majority of its methods are defined in `cOrganism.cc`, the compiler only needs to be compile these methods once. During the link phase the linker connects the references together.

Occasionally short functions are implemented with their bodies directly in the header file. When a function compiled in one object file is run from another, the linker basically points the caller to the location of that function. A few extra CPU cycles must be expended while the program jumps to the function. Many small function, especially one line access methods, can be made inline, which means it will be placed, as a whole, right inside of the function that calls it. If the function is short enough, it only takes up as much space as the call to it would have taken anyway, and hence does not increase the size of the executable.

## Directory Structure

The following sections provide a high level overview of the directory structure within the Avida source code distribution. Many directory sections contain partial listings of the files contained within them, however these list are not to be considered complete.

### Top Level Directory

All of the files for the current version of Avida reside in the directory labeled `trunk/` by default when checked out of Subversion. In addition to the subdirectories `documentation/`, `source/` and `support/` (all described below), this directory contains several key sources of information and automatic compilation files. The most important of these are described here.

`AUTHORS`
  This file contains information about the authorship of Avida.
`Avida.xcodeproj`
  This file (or directory on non-Mac OS platforms) contains the Xcode project information for development and building Avida within the Xcode IDE on Mac OS. This project file requires Xcode 2.1 or greater.
`BuildAvida.py`
  The main entry point for the new experimental SCONS python based build system.
`CHANGES`
  A listing of important changes to Avida that affect users of previous releases.
`COPYING`
`COPYING.gpl`
  These files contain copyright information.
`KNOWN_BUGS`
  A listing of known issues that may be pertinent to various users.
`README`
  A general guide on how to get started once you put the Avida files on your machine.
`build_avida`
  A one step build script for compiling Avida under Unix platforms that have CMake installed.
`test_avida`
  After Avida has been built, this script serves as an entry point for executing a series of consistency tests on the produced executable.

### Directory: `build/work/` (CMake)
Directory: `build/{Target Name}/work/` (Xcode)

After compilation, this directory will contain all of the configuration files necessary for Avida (explained in more detail under in their own documentation files). The key files and directories here are:

`analyze.cfg`
  The default file used to write analysis scripts.
`avida.cfg`
  This is the main configuration file that is used by default.
`environment.cfg`
  This file contains the default environment information.
`events.cfg`
  This file contains the default event list.
`inst_set.default`
  This is the main, heads-based instruction set that is used by default.
`organism.default`
  This file contains the default starting ancestor of length 100.
`data/`
  This is the name of the default output directory and is created by Avida if it does not exist. The name and location of this directory can be configured in `avida.cfg`.

### Directory: `source/`

This is a large sub-directory structure that contains all of the source code that makes up Avida. Each sub-directory here includes its own CMake and SCONS build information. The high level purpose of each sub-directory is:

`actions/`
  Contains various source files that define action classes that are usable as schedule events and analyze commands. Also contains the cActionLibrary responsible for instantiating objects based on cString names.
`analyze/`
  Contains classes responsible for performing and managing data from detailed analyses.
`classification/`
  Classes that define and manage classification of current and past properties of the population are stored here.
`cpu/`
  Files and classes used to implement all of the virtual hardware within the Avida software.
`drivers/`
  Classes and infrastructure used to orchestrate the execution of Avida.
`event/`
  Contains classes responsible for event scheduling and triggering.
`main/`
  Contains all of the core classes that define the world and the population within it.
`platform/`
  Contains platform specific software in various subdirectories, such as the high performance malloc library for POSIX platforms.
`targets/`
  Target (executable) specific source code. The source code of the NCurses viewer resides in the `avida-viewer/` subdirectory.
`tools/`
  Contains a number of generic tools classes, including custom data structures and robust string manipulation classes.

### Directory: `source/main/`

This sub-directory contains all of the core source code files for the software. For ease, there are two separate groups of more important components and less important components, each in alphabetical order. The syntax `name.??` refers to header/source file pairs, `name.h` and `name.cc`. The more important files are:

`cAvidaConfig.??`
  These files define the cAvidaConfig object that maintains the current configuration state of Avida. This class is initialized by the avida.cfg file and processed command line arguments and can be modified via various events during the run.
`cEnvironment.??`
  This file defines the cEnvironment object, which controls all of the environmental interactions in an Avida run. It makes use of reactions, resources, and tasks.
`cGenome.??`
  The cGenome object maintains of a sequence of objects of class cInstruction.
`cInstruction.??`
  The cInstruction class is very simple, maintaining a single instruction in Avida.
`cInstLibBase.h`
  The cInstLibBase class serves as a base class for objects that associate instructions with their corresponding functionality in the virtual hardware.
`cMutationRates.??`
  These files contain the cMutationRates class which maintain the probability of occurrence for each type of mutation.
`cOrganism.??`
  The cOrganism class represents a single organism, and contains the initial genome of that organism, its phenotypic information, its virtual hardware, etc.
`cPopulation.??`
  The cPopulation class manages the organisms that exist in an Avida population. It maintains a collection of cPopulationCell objects (either as A grid, or independent cells for mass action) and contains the scheduler, genebank, event manager, etc.
`cPopulationCell.??`
  A cPopulationCell is a single location in an Avida population. It can contain an organism, and has its own mutation rates (but not yet its own environment.)
`cStats.??`
  A cStats object keeps track of many different population-wide statistics.
`cWorld.??`
  The cWorld object contains all of the state information used by a particular run and can be used to access many globally important classes.

Below are various less important files that may still be useful to know about:

`cOrgInterface.h`
  The cOrgInterface class defines the interface used by organisms to interact back with the population or test CPU environment.
`cReaction.??`
  The cReaction class contains all of the information for what triggers a reaction, its restrictions, and the process that occurs.
`cReactionResult.??`
  The cReactionResult class contains all of the information about the results of a reaction after one occurs, such as the amount of resources consumed, what the merit change is, what tasks triggered it, etc.
`cResource.??`
  The cResource class contains information about a single resource, such as its inflow rate, outflow, name, etc.
`cResourceCount.??`
  The resource count keeps track of how much of each resource is present in the region being tracked.
`cTaskLib.??`
  This class contains all of the information associated with task evaluation.

### Directory: `source/analyze/`

The primary class in this directory is `cAnalyze`. This class processes `analyze.cfg` files to perform data analysis on run data. The additional classes in this directory support various types of analyses, along with provide the foundation for multithreaded execution. The `cAnalyzeJobQueue` object, instatiated by `cAnalyze`, orchestrates queuing and executing jobs on parallel worker objects.

### Directory: `source/cpu/`

This sub-directory contains the files used to define the virtual CPUs in Avida.

`cCodeLabel.??`
  The cCodeLabel class marks labels (series of no-operation instructions) in a genome. These are used when a label needs to be used as an instruction argument.
`cCPUMemory.??`
  The cCPUMemory class inherits from the cGenome class, extending its functionality to facilitate insertions and deletions. It also associates flags with each instruction in the genome to mark if they have been executed, copied, mutated, etc.
`cCPUStack.??`
  The cCPUStack class is an integer-stack component in the virtual CPUs.
`cHardwareBase.??`
  The cHardwareBase class is an abstract base class that all other hardware types must be overloaded from. It has minimal built in functionality.
`cHardwareCPU.??`
  The cHardwareCPU class extends cHardwareBase into a proper virtual CPU, with registers, stacks, memory, IO Buffers, etc.
`cHardwareManager.??`
  The cHardwareManager manages the building of new hardware as well Test CPU creation.
`cHardwareSMT.??`
  This class represents the in process experimental implementation of next generation virtual hardware.
`cHardwareTransSMT.??`
  An intermediate step on the path to cHardwareSMT, this transitional hardware is used in a number of ongoing research projects.
`cHeadCPU.??`
  The cCPUHead class implements a head pointing to a position in the memory of a virtual CPU.
`cTestCPU.??`
  The cTestCPU class maintains a test environment to run organisms in that we don't want to be able to directly affect the real population.
`cTestUtil.??`
  The cTestUtil utility class is for test-related functions that require a test CPU, such as printing out a genome to a file with collected information.

### Directory: `source/tools/`

The tools sub-directory contains C++ source code that is used throughout Avida, but is not specific to the project.

`cDataEntry.??`
  Associates data names with functions for printing out data file with a user specified format.
`cDataFile.??`
  A class useful for handling output files with named columns.
`cDataFileManager.??`
  This class manages a collection of data files and handles the creation and output of user-designed data files at runtime.
`cMerit.??`
  Provides a very large integer number, dissectable in useful ways.
`cRandom.??`
  A powerful and portable random number generator, that can output numbers in a variety of formats.
`cString.??`
  A standard string object, but with lots of functionality.
`cStringList.??`
  A specialized class for collections of strings, with added functionality over a normal list.
`cStringUtil.??`
  Contains a bunch of static methods to manipulate and compare strings.
`functions.h`
  Some useful math functions such as Min, Max, and Log.

Templates are special classes that interact with another data-type that doesn't need to be specified until the programmer instantiates an object in the class. Its a hard concept to get used to, but allows for remarkably flexible programming, and makes very reusable code. The main drawback (other than brain-strain) is that templates must be entirely defined in header files since separate code is generated for each class the template interacts with.

`tArray.h`
  A fixed-length array template; array sizes may be adjusted manually when needed.
`tBuffer.h`
  A container that keeps only the last N entries, indexed with the most recent first.
`tDictionary.h`
  A container template that allows the user to search for a target object based on a keyword (of type cString).
`tHashTable.h`
  A mapping container that maps keys to values using a hashing function to provide fast lookup.
`tList.h`
  A reasonably powerful linked list and iterators. The list will keep track of the iterators and never allow them to have an illegal value.
`tManagedPointerArray.h`
  A derivative of tArray, a managed pointer array is ideal for storing arrays of large objects that may need to be resized. The backing storage mechanism simple resizes an array of pointers, preventing the unnecessary copying of large objects.
`tMatrix.h`
  A fixed size matrix template with arbitrary indexing.
`tMemTrack.h`
  This is a template that can be put over any class or data type to keep track of it. If all creations of objects in the class are done through this template rather than (or in conjunction with) "new", memory leaks should be detectable. This is new, and not yet used in Avida.
`tSmartArray.h`
  A derivative of tArray that provides hidden capacity management. This type of array is ideal for arrays of small objects that may be resized often.
`tVector.h`
  A variable-length array object; array sizes will be automatically adjusted to accommodate any positions accessed in it.

### Directory: `support/config/`

This directory contains all of the originals of the files that are copied into the `work/` directory on the installation process for the user to modify. There is also a `misc/` sub-directory under here with additional, optional configuration files that you may want to look at to see other possible pre-configured settings.

Return to the Index