| 349 |   |  pfc = peak FLOP count(J) | 
                      
                        | 350 |   |  approx = true; | 
                      
                        | 351 |   |  if pfc > wu.fpops_bound | 
                      
                        | 352 |   |    host_app_version.scale_probation = true | 
                      
                        | 353 |   |    host_app_version.error_rate = initial value  // replicate for a while | 
                      
                        | 354 |   |    if app.min_avg_pfc is defined | 
                      
                        | 355 |   |      F = app.min_avg_pfc * wu.fpops_est | 
                      
                        | 356 |   |    else | 
                      
                        | 357 |   |      F = wu.fpops_est | 
                      
                        | 358 |   |  else | 
                      
                        | 359 |   |    if job is anonymous platform | 
                      
                        | 360 |   |      if app.min_avg_pfc is defined | 
                      
                        | 361 |   |        if host_app_version.pfc_avg is above sample threshold | 
                      
                        | 362 |   |             and not host_app_version.scale_probation | 
                      
                        | 363 |   |          F = app.min_avg_pfc / host_app_version.pfc_avg | 
                      
                        | 364 |   |          approx = false | 
                      
                        | 365 |   |        else | 
                      
                        | 366 |   |          F = app.min_avg_pfc * wu.fpops_est | 
                      
                        | 367 |   |      else | 
                      
                        | 368 |   |        F = wu.fpops_est | 
                      
                        | 369 |   |    else | 
                      
                        | 370 |   |      F = pfc; | 
                      
                        | 371 |   |          host_scale = 0 | 
                      
                        | 372 |   |      if host_app_version.pfc_avg is above sample threshold | 
                      
                        | 373 |   |           and not host_app_version.scale_probation | 
                      
                        | 374 |   |            host_scale = min(10, app_version.pfc_avg / host_app_version.pfc_avg) | 
                      
                        | 375 |   |      if app_version.pfc_scale is defined | 
                      
                        | 376 |   |        F *= app_version.pfc_scale | 
                      
                        | 377 |   |            if host_scale | 
                      
                        | 378 |   |          F *= host_scale | 
                      
                        | 379 |   |          approx = false | 
                      
                        | 380 |   |      else | 
                      
                        | 381 |   |            if host_scale | 
                      
                        | 382 |   |          F *= host_scale | 
                      
                        | 383 |   |          app_version.pfc_avg.update(F) | 
                      
                        | 384 |   |          host_app_version.pfc_avg.update(F) | 
                      
                      
                        |   | 349 | double claimed_pfc(J, double& f, bool& approx): | 
                      
                        |   | 350 |         pfc = peak FLOP count(J) | 
                      
                        |   | 351 |         approx = true; | 
                      
                        |   | 352 |         if no app version info (relic of old scheduler) | 
                      
                        |   | 353 |                 F = wu.fpops_est | 
                      
                        |   | 354 |                 return | 
                      
                        |   | 355 |         if pfc > wu.fpops_bound | 
                      
                        |   | 356 |                 host_app_version.scale_probation = true | 
                      
                        |   | 357 |                 host_app_version.error_rate = initial value     // replicate for a while | 
                      
                        |   | 358 |                 if app.min_avg_pfc is defined | 
                      
                        |   | 359 |                         F = app.min_avg_pfc * wu.fpops_est | 
                      
                        |   | 360 |                 else | 
                      
                        |   | 361 |                         F = wu.fpops_est | 
                      
                        |   | 362 |         else | 
                      
                        |   | 363 |                 if job is anonymous platform | 
                      
                        |   | 364 |                         if app.min_avg_pfc is defined | 
                      
                        |   | 365 |                                 if host_app_version.pfc_avg is above sample threshold | 
                      
                        |   | 366 |                                                  and not host_app_version.scale_probation | 
                      
                        |   | 367 |                                         F *= app.min_avg_pfc / host_app_version.pfc_avg | 
                      
                        |   | 368 |                                         approx = false | 
                      
                        |   | 369 |                                 else | 
                      
                        |   | 370 |                                         F = app.min_avg_pfc * wu.fpops_est | 
                      
                        |   | 371 |                         else | 
                      
                        |   | 372 |                                 F = wu.fpops_est | 
                      
                        |   | 373 |                 else | 
                      
                        |   | 374 |                         F = pfc; | 
                      
                        |   | 375 |                         host_scale = 0 | 
                      
                        |   | 376 |                         if host_app_version.pfc_avg is above sample threshold | 
                      
                        |   | 377 |                                         and app_version.pfc is above sample threshold | 
                      
                        |   | 378 |                                         and not host_app_version.scale_probation | 
                      
                        |   | 379 |                                         and host_app_version.pfc_avg <> 0 | 
                      
                        |   | 380 |                                 host_scale = app_version.pfc_avg / host_app_version.pfc_avg | 
                      
                        |   | 381 |                                 if (host_scale) > 10 | 
                      
                        |   | 382 |                                         host_scale = 10 | 
                      
                        |   | 383 |                         if app_version.pfc_scale is defined | 
                      
                        |   | 384 |                                 F *= app_version.pfc_scale | 
                      
                        |   | 385 |                                 if host_scale | 
                      
                        |   | 386 |                                         F *= host_scale | 
                      
                        |   | 387 |                                         approx = false | 
                      
                        |   | 388 |                         else | 
                      
                        |   | 389 |                                 if host_scale | 
                      
                        |   | 390 |                                         F *= host_scale | 
                      
                        |   | 391 |                         app_version.pfc_avg.update(pfc) | 
                      
                        |   | 392 |                 host_app_version.pfc_avg.update(pfc) | 
                      
                        |   | 393 |                 (host_app_version.et.update(elapsed time)) | 
                      
                        |   | 394 |                 (host_app_version.turnaround.update(turnaround time)) |