= Specifying plan classes in XML =

You can specify plan classes using an XML configuration file with the format
{{{
<plan_classes>
   <plan_class>
      ... specification of a plan class
   </plan_class>
   ... more plan class specifications
</plan_classes>
}}}

Name this file '''plan_class_spec.xml''' and put it in your project directory.
This will '''replace''' the built in plan classes!

== Examples ==

An example configuration file is [http://boinc.berkeley.edu/trac/browser/boinc-v2/sched/plan_class_spec.xml.sample here].
This file specifies the [AppPlan predefined plan classes].

== Specification format ==

The specification of a plan class has the following format.
All elements except '''<name>''' are optional.
In version numbers, M is major, m is minor, R is release.

 <name>X</name> :: the name of the plan class
 <projected_flops_scale>x</projected_flops_scale>:: multiply projected FLOPS by this factor.
   Use this to favor one class over another.
   For example, if you have both SSE and non-SSE versions, use 1.1 and 1.0 respectively.
 <os_regex>regex</os_regex>:: use only hosts whose operating system version matches the given regular expression
 <cpu_feature>x</cpu_feature>:: a required CPU feature (such as sse3). You can include more than one.
 <host_summary_regex>regex</host_summary_regex>:: only sends the app version to hosts with host.serialnum field that matches the given regular expression.

The following lets you use a project preference to decide whether to use the app version:
 <project_prefs_tag>x</project_prefs_tag>:: the name of the tag
 <project_prefs_regex>x</project_prefs_regex>:: the contents must match this regular expression

Fields for multicore apps:
 <min_ncpus>x</min_ncpus> :: run only on hosts with at least X usable CPUs.
 <max_threads>x</max_threads>:: use at most this many CPUs

Fields for GPU apps:

 <gpu_type>X</gpu_type>:: the GPU type ('''nvidia''', '''amd''', or '''intel''')
 <cpu_frac>x</cpu_frac>:: the fraction of total FLOPs that are done by the CPU.
   This is used to calculate CPU usage and estimated FLOPS.
 <min_gpu_ram_mb>x</min_gpu_ram_mb>:: The minimum amount of GPU RAM.
   This is needed because older clients report total RAM
   but not available RAM.
 <gpu_ram_used_mb>x</gpu_ram_used_mb>:: require this much available GPU RAM
 <gpu_peak_flops_scale>x</gpu_peak_flops_scale>:: scale GPU peak speed by this (default 1).
 <ngpus>x</ngpus>:: how many GPUs will be used
 <min_driver_version>x</min_driver_version>:: minimum display driver version.
  AMD driver versions are represented as MMmmRRRR.
  NVIDIA driver versions are represented as MMMmm.
 <max_driver_version>x</max_driver_version>:: maximum display driver version
 <cuda/>:: CUDA application (NVIDIA)
 <cal/>:: CAL application (AMD)
 <opencl/>:: OpenCL application
 <gpu_utilization_tag>x</gpu_utilization_tag>:: you can use a project-specific preferences to let users
   scale the # of GPUs used.
   This is the tag name.
 <without_opencl>0|1</without_opencl>:: send this version only to hosts without OpenCL capability

Fields for AMD/ATI GPU apps:

 <need_ati_libs/>:: Require libraries named "ati", not "amd".
 <need_amd_libs/>:: Require libraries named "amd".
  You can verify which DLLs your application is linked against using 
  [http://www.dependencywalker.com/ Dependency Walker] against your application. 
  If your executable contains DLL names prefixed with 'ati', use this option.
  These flags are usually not needed for OpenCL apps.

 <min_cal_target>N</min_cal_target> ::
 <max_cal_target>N</max_cal_target> ::
  Min and max CAL targets:
{{{
typedef enum CALtargetEnum {
    CAL_TARGET_600,                /**< R600 GPU ISA */     
    CAL_TARGET_610,                /**< RV610 GPU ISA */    
    CAL_TARGET_630,                /**< RV630 GPU ISA */
    CAL_TARGET_670,                /**< RV670 GPU ISA */
    CAL_TARGET_7XX,                /**< R700 class GPU ISA */
    CAL_TARGET_770,                /**< RV770 GPU ISA */
    CAL_TARGET_710,                /**< RV710 GPU ISA */
    CAL_TARGET_730,                /**< RV730 GPU ISA */
    CAL_TARGET_CYPRESS,            /**< CYPRESS GPU ISA */
    CAL_TARGET_JUNIPER,            /**< JUNIPER GPU ISA */
    CAL_TARGET_REDWOOD,            /**< REDWOOD GPU ISA */
    CAL_TARGET_CEDAR,               /**< CEDAR GPU ISA */
    CAL_TARGET_RESERVED0,
    CAL_TARGET_RESERVED1,           
    CAL_TARGET_WRESTLER,            /**< WRESTLER GPU ISA */
    CAL_TARGET_CAYMAN,              /**< CAYMAN GPU ISA */
    CAL_TARGET_KAUAI,           /** added by me **/
    CAL_TARGET_BARTS,               /**< BARTS GPU ISA */
    CAL_TARGET_TURKS,          /** added by me **/
    CAL_TARGET_CAICOS   /** added by me **/
} CALtarget;
}}}

Fields for NVIDIA GPU apps:

 <min_nvidia_compcap>MMmm</min_nvidia_compcap>:: minimum compute capability
 <max_nvidia_compcap>MMmm</max_nvidia_compcap>:: maximum compute capability

Fields for CUDA apps

 <min_cuda_version>MMmmm</min_cuda_version>:: minimum CUDA version
 <max_cuda_version>MMmmm</max_cuda_version>:: maximum CUDA version

Fields for OpenCL apps

 <min_opencl_version>MMmm</min_opencl_version>:: minimum OpenCL version
 <max_opencl_version>MMmm</max_opencl_version>:: maximum OpenCL version

Fields for OpenCL apps for AMD
 <min_opencl_driver_revision>MMmmrr</min_opencl_driver_revision>:: minimum OpenCL driver revision
 <max_opencl_driver_revision>MMmmrr</max_opencl_driver_revision>:: maximum OpenCL driver revision

Fields for !VirtualBox apps

 <virtualbox/> :: !VirtualBox application; send only to hosts with !VirtualBox installed
 <min_vbox_version>MMmmrr</min_vbox_version>:: minimum !VirtualBox version
 <max_vbox_version>MMmmrr</max_vbox_version>:: maximum !VirtualBox version
 <is64bit/> :: 64-bit application.
 <vm_accel_required/> ::  send only to hosts with enabled VM hardware acceleration.

Note: !VirtualBox apps can be multicore (set <min_ncpus> and <max_threads>).
However, when sent to hosts without enabled VM hardware acceleration,
they'll be run single-core.

Fields for non-compute-intensive apps:
 <avg_ncpus>x</avg_ncpus>:: average # CPUs used.  Use for non-compute-intensive apps;
   for others it's calculated for you.