Changes between Version 22 and Version 23 of CreditNew


Ignore:
Timestamp:
Mar 8, 2010, 4:37:13 PM (14 years ago)
Author:
davea
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • CreditNew

    v22 v23  
    77For GPUs, it's given by a manufacturer-supplied formula.
    88
    9 However, other factors affect application performance.
    10 For example, applications access memory,
    11 and the speed of a host's memory system is not reflected
    12 in its Whetstone score.
     9Other factors,
     10such as the speed of a host's memory system,
     11affect application performance.
    1312So a given job might take the same amount of CPU time
    1413and a 1 GFLOPS host as on a 10 GFLOPS host.
    … …  
    2221Notes:
    2322
    24  * The peaks FLOPS of a device is single or double precision,
    25    whichever is higher.
     23 * For our purposes, the peak FLOPS of a device
     24   is single or double precision, whichever is higher.
    2625   Differentiating between single and double would unnecessarily
    2726   complicate things, and the distinction will disappear soon anyway.
    … …  
    9796
    9897 * Limited project neutrality: different projects should grant
    99    about the same amount of credit per CPU hour, averaged over hosts.
     98   about the same amount of credit per host-hour, averaged over hosts.
    10099   Projects with GPU apps should grant credit in proportion
    101100   to the efficiency of the apps.
    102101   (This means that projects with efficient GPU apps will
    103    grant more credit on average.  That's OK).
     102   grant more credit than projects with inefficient apps.  That's OK).
    104103
    105104== Peak FLOP Count (PFC) ==
    … …  
    140139the granted credit per job is adjusted
    141140so that the average is the same for each version.
    142 The adjustment is always downwards:
    143 we maintain the average PFC^mean^(V) of PFC() for each app version V,
    144 find the minimum X.
     141
     142We maintain the average PFC^mean^(V) of PFC() for each app version V.
     143We periodically compute PFC^mean^(CPU) and PFC^mean^(GPU),
     144and let X be the min of these.
    145145An app version V's jobs are then scaled by the factor
    146146
    147147 S(V) = (X/PFC^mean^(V))
    148 
    149148
    150149The result for a given job J
    151150is called "Version-Normalized Peak FLOP Count", or VNPFC(J):
    152151
    153  VNPFC(J) = PFC(J) * (X/PFC^mean^(V))
     152 VNPFC(J) = S(V) * PFC(J)
    154153
    155154Notes:
    … …  
    174173   so it's probably better not to.
    175174
    176 
    177175== Cross-project normalization ==
    178176
    … …  
    190188then for each version V we let
    191189S(V) be the average scaling factor
    192 for that GPU type among projects that do have both CPU and GPU versions.
     190for that plan class among projects that do have both CPU and GPU versions.
    193191This factor is obtained from a central BOINC server.
    194192V's jobs are then scaled by S(V) as above.
    … …  
    196194Notes:
    197195
    198  * Projects will run a periodic script to update the scaling factors.
    199  * Rather than GPU type, we'll probably use plan class,
     196 * wu use plan class,
    200197   since e.g. the average efficiency of CUDA 2.3 apps may be different
    201198   than that of CUDA 2.1 apps.
    202199 * Initially we'll obtain scaling factors from large projects
    203200   that have both GPU and CPU apps (e.g., SETI@home).
    204    Eventually we'll use an average (weighted by work done) over multiple projects
    205    (see below).
     201   Eventually we'll use an average (weighted by work done)
     202   over multiple projects (see below).
    206203
    207204== Host normalization ==
    208205
    209 Assuming that hosts are sent jobs for a given app uniformly,
    210 then, for that app,
    211 hosts should get the same average granted credit per job.
    212 To ensure this, for each application A we maintain the average VNPFC^mean^(A),
    213 and for each host H we maintain VNPFC^mean^(H, A).
     206The second normalization is across hosts.
     207Assume jobs for a given app are distributed uniformly among hosts.
     208Then the average credit per job should be the same for all hosts.
     209To ensure this, for each app version V and host H
     210we maintain PFC^mean^(H, A).
    214211The '''claimed FLOPS''' for a given job J is then
    215212
    216  F = VNPFC(J) * (VNPFC^mean^(A)/VNPFC^mean^(H, A))
     213 F = VNPFC(J) * (PFC^mean^(V)/PFC^mean^(H, A))
    217214
    218215and the claimed credit (in Cobblestones) is
    … …  
    221218
    222219There are some cases where hosts are not sent jobs uniformly:
     220
    223221 * job-size matching (smaller jobs sent to slower hosts)
    224222 * GPUGrid.net's scheme for sending some (presumably larger)
    … …  
    228226
    229227This can be done by dividing
    230 each sample in the computation of VNPFC^mean^ by WU.rsc_fpops_est
     228each sample in the computation of PFC^mean^ by WU.rsc_fpops_est
    231229(in fact, there's no reason not to always do this).
    232230
    … …  
    236234   and increases the claimed credit of hosts that are more efficient
    237235   than average.
    238  * VNPFC^mean^ is averaged over jobs, not hosts.
     236 * PFC^mean^ is averaged over jobs, not hosts.
    239237
    240238== Computing averages ==
    … …  
    248246 * A given sample may be wildly off,
    249247   and we can't let this mess up the average.
    250  * Averages should be weighted by job size.
    251248
    252249In addition, we may as well maintain the variance of the quantities,
    … …  
    452449
    453450== Compatibility ==
     451