Print this page
5042 stop using deprecated atomic functions

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/os/lgrp.c
          +++ new/usr/src/uts/common/os/lgrp.c
↓ open down ↓ 2765 lines elided ↑ open up ↑
2766 2766                                  new += ((long long)(nrcpus - q) * f -
2767 2767                                      ((r * f) >> 16)) >> 7;
2768 2768  
2769 2769                                  /*
2770 2770                                   * Check for overflow
2771 2771                                   */
2772 2772                                  if (new > LGRP_LOADAVG_MAX)
2773 2773                                          new = LGRP_LOADAVG_MAX;
2774 2774                                  else if (new < 0)
2775 2775                                          new = 0;
2776      -                        } while (cas32((lgrp_load_t *)&lpl->lpl_loadavg, old,
2777      -                            new) != old);
     2776 +                        } while (atomic_cas_32((lgrp_load_t *)&lpl->lpl_loadavg,
     2777 +                            old, new) != old);
2778 2778                  } else {
2779 2779                          /*
2780 2780                           * We're supposed to update the load, but not age it.
2781 2781                           * This option is used to update the load (which either
2782 2782                           * has already been aged in this 1/10 sec. interval or
2783 2783                           * soon will be) to account for a remotely executing
2784 2784                           * thread.
2785 2785                           */
2786 2786                          do {
2787 2787                                  old = new = lpl->lpl_loadavg;
2788 2788                                  new += f;
2789 2789                                  /*
2790 2790                                   * Check for overflow
2791 2791                                   * Underflow not possible here
2792 2792                                   */
2793 2793                                  if (new < old)
2794 2794                                          new = LGRP_LOADAVG_MAX;
2795      -                        } while (cas32((lgrp_load_t *)&lpl->lpl_loadavg, old,
2796      -                            new) != old);
     2795 +                        } while (atomic_cas_32((lgrp_load_t *)&lpl->lpl_loadavg,
     2796 +                            old, new) != old);
2797 2797                  }
2798 2798  
2799 2799                  /*
2800 2800                   * Do the same for this lpl's parent
2801 2801                   */
2802 2802                  if ((lpl = lpl->lpl_parent) == NULL)
2803 2803                          break;
2804 2804                  ncpu = lpl->lpl_ncpu;
2805 2805          }
2806 2806  }
↓ open down ↓ 540 lines elided ↑ open up ↑
3347 3347                                          new -= LGRP_LOADAVG_MAX_EFFECT(ncpu);
3348 3348                                          if (new > old) {
3349 3349                                                  /*
3350 3350                                                   * this can happen if the load
3351 3351                                                   * average was aged since we
3352 3352                                                   * added in the anticipatory
3353 3353                                                   * load
3354 3354                                                   */
3355 3355                                                  new = 0;
3356 3356                                          }
3357      -                                } while (cas32(
     3357 +                                } while (atomic_cas_32(
3358 3358                                      (lgrp_load_t *)&lpl->lpl_loadavg, old,
3359 3359                                      new) != old);
3360 3360  
3361 3361                                  lpl = lpl->lpl_parent;
3362 3362                                  if (lpl == NULL)
3363 3363                                          break;
3364 3364  
3365 3365                                  ncpu = lpl->lpl_ncpu;
3366 3366                                  ASSERT(ncpu > 0);
3367 3367                          }
↓ open down ↓ 48 lines elided ↑ open up ↑
3416 3416                          ASSERT(ncpu > 0);
3417 3417                          do {
3418 3418                                  old = new = lpl->lpl_loadavg;
3419 3419                                  new += LGRP_LOADAVG_MAX_EFFECT(ncpu);
3420 3420                                  /*
3421 3421                                   * Check for overflow
3422 3422                                   * Underflow not possible here
3423 3423                                   */
3424 3424                                  if (new < old)
3425 3425                                          new = UINT32_MAX;
3426      -                        } while (cas32((lgrp_load_t *)&lpl->lpl_loadavg, old,
3427      -                            new) != old);
     3426 +                        } while (atomic_cas_32((lgrp_load_t *)&lpl->lpl_loadavg,
     3427 +                            old, new) != old);
3428 3428  
3429 3429                          lpl = lpl->lpl_parent;
3430 3430                          if (lpl == NULL)
3431 3431                                  break;
3432 3432                  }
3433 3433                  t->t_anttime = gethrtime();
3434 3434          }
3435 3435  }
3436 3436  
3437 3437  /*
↓ open down ↓ 1004 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX