| 94 | | if (!strcmp(plan_class, "cuda")) { |
| 95 | | COPROC_CUDA* cp = (COPROC_CUDA*)sreq.coprocs.lookup("CUDA"); |
| 96 | | if (!cp) { |
| 97 | | if (config.debug_version_select) { |
| 98 | | log_messages.printf(MSG_NORMAL, |
| 99 | | "[version] Host lacks CUDA coprocessor for plan class cuda\n" |
| 100 | | ); |
| 101 | | } |
| 102 | | add_no_work_message("Your computer has no NVIDIA GPU"); |
| | 113 | if (!strcmp(plan_class, "cuda23")) { |
| | 114 | if (!cuda_check(c, hu, |
| | 115 | 100, // minimum compute capability (1.0) |
| | 116 | 200, // max compute capability (2.0) |
| | 117 | 2030, // min CUDA version (2.3) |
| | 118 | 19500, // min display driver version (195.00) |
| | 119 | 384*MEGA, // min video RAM |
| | 120 | 1., // # of GPUs used (may be fractional, or an integer > 1) |
| | 121 | .01, // fraction of FLOPS done by the CPU |
| | 122 | .21 // estimated GPU efficiency (actual/peak FLOPS) |
| | 123 | )) { |
| 106 | | Check the compute capability (1.0 or better): |
| | 128 | |
| | 129 | To define a new ATI/CAL plan class, add a new clause |
| | 130 | to '''app_plan_ati()'''. |
| | 131 | For example: |
| | 132 | {{{ |
| | 133 | if (!strcmp(plan_class, "ati14")) { |
| | 134 | if (!ati_check(c, hu, |
| | 135 | 1004000, // min display driver version (10.4) |
| | 136 | false, // require libraries named "ati", not "amd" |
| | 137 | 384*MEGA, // min video RAM |
| | 138 | 1., // # of GPUs used (may be fractional, or an integer > 1) |
| | 139 | .01, // fraction of FLOPS done by the CPU |
| | 140 | .21 // estimated GPU efficiency (actual/peak FLOPS) |
| | 141 | )) { |
| | 142 | return false; |
| | 143 | } |
| | 144 | } |
| | 145 | }}} |
| | 146 | |
| | 147 | To define a new OpenCL plan class, add a new clause to |
| | 148 | '''app_plan_opencl()'''. |
| | 149 | For example: |
| 109 | | int v = (cp->prop.major)*100 + cp->prop.minor; |
| 110 | | if (v < 100) { |
| 111 | | if (config.debug_version_select) { |
| 112 | | log_messages.printf(MSG_NORMAL, |
| 113 | | "[version] CUDA version %d < 1.0\n", v |
| 114 | | ); |
| 115 | | } |
| 116 | | add_no_work_message( |
| 117 | | "Your NVIDIA GPU lacks the needed compute capability" |
| 118 | | ); |
| 119 | | } |
| | 152 | if (!strcmp(plan_class, "opencl_nvidia_101")) { |
| | 153 | return opencl_check( |
| | 154 | c, hu, |
| | 155 | 101, // OpenCL version (1.1) |
| | 156 | 256*MEGA, // min video RAM |
| | 157 | 1, // # of GPUs used |
| | 158 | .1, // fraction of FLOPS done by the CPU |
| | 159 | .21 // estimated GPU efficiency (actual/peak FLOPS) |
| | 160 | ); |
| | 161 | } |
| 121 | | Check the CUDA runtime version. |
| 122 | | As of client version 6.10, all clients report the CUDA runtime version (cp->cuda_version); use that if it's present. |
| 123 | | In 6.8 and earlier, the CUDA runtime version isn't reported. |
| 124 | | Windows clients report the driver version, from which the CUDA version can be inferred; |
| 125 | | Linux clients don't return the driver version, so we don't know what the CUDA version is. |
| 126 | | |
| 127 | | {{{ |
| 128 | | // for CUDA 2.3, we need to check the CUDA RT version. |
| 129 | | // Old BOINC clients report display driver version; |
| 130 | | // newer ones report CUDA RT version |
| 131 | | // |
| 132 | | if (!strcmp(plan_class, "cuda23")) { |
| 133 | | if (cp->cuda_version) { |
| 134 | | if (cp->cuda_version < 2030) { |
| 135 | | add_no_work_message("CUDA version 2.3 needed"); |
| 136 | | return false; |
| 137 | | } |
| 138 | | } else if (cp->display_driver_version) { |
| 139 | | if (cp->display_driver_version < PLAN_CUDA23_MIN_DRIVER_VERSION) { |
| 140 | | sprintf(buf, "NVIDIA display driver %d or later needed", |
| 141 | | PLAN_CUDA23_MIN_DRIVER_VERSION |
| 142 | | ); |
| 143 | | } |
| 144 | | } else { |
| 145 | | add_no_work_message("CUDA version 2.3 needed"); |
| 146 | | return false; |
| 147 | | } |
| 148 | | }}} |
| 149 | | Check for the amount of video RAM: |
| 150 | | |
| 151 | | {{{ |
| 152 | | if (cp->prop.dtotalGlobalMem < PLAN_CUDA_MIN_RAM) { |
| 153 | | if (config.debug_version_select) { |
| 154 | | log_messages.printf(MSG_NORMAL, |
| 155 | | "[version] CUDA mem %d < %d\n", |
| 156 | | cp->prop.dtotalGlobalMem, PLAN_CUDA_MIN_RAM |
| 157 | | ); |
| 158 | | } |
| 159 | | sprintf(buf, |
| 160 | | "Your NVIDIA GPU has insufficient memory (need %.0fMB)", |
| 161 | | PLAN_CUDA_MIN_RAM |
| 162 | | ); |
| 163 | | add_no_work_message(buf); |
| 164 | | return false; |
| 165 | | } |
| 166 | | }}} |
| 167 | | Estimate the FLOPS: |
| 168 | | |
| 169 | | {{{ |
| 170 | | hu.flops = cp->flops_estimate(); |
| 171 | | }}} |
| 172 | | Estimate its CPU usage: |
| 173 | | |
| 174 | | {{{ |
| 175 | | // assume we'll need 0.5% as many CPU FLOPS as GPU FLOPS |
| 176 | | // to keep the GPU fed. |
| 177 | | // |
| 178 | | double x = (hu.flops*0.005)/sreq.host.p_fpops; |
| 179 | | hu.avg_ncpus = x; |
| 180 | | hu.max_ncpus = x; |
| 181 | | }}} |
| 182 | | Indicate the number of GPUs used. Typically this will be 1. |
| 183 | | If your application uses only a fraction X<1 of the CPU processors, |
| 184 | | and a fraction Y<1 of video RAM, reports the number of GPUs as min(X, Y). |
| 185 | | In this case BOINC will attempt to run multiple jobs per GPU is possible. |
| 186 | | |
| 187 | | {{{ |
| 188 | | hu.ncudas = 1; |
| 189 | | }}} |
| 190 | | Return true to indicate that the application can be run on the host: |
| 191 | | |
| 192 | | {{{ |
| 193 | | return true; |
| 194 | | }}} |
