src/nice.go

   1 package nncp
   2
   3 import (
   4         "errors"
   5         "fmt"
   6         "regexp"
   7         "strconv"
   8         "strings"
   9 )
  10
  11 const (
  12         NiceFlash    = 32
  13         NicePriority = 96
  14         NiceNormal   = 160
  15         NiceBulk     = 224
  16
  17         DefaultNiceExec = NicePriority
  18         DefaultNiceFreq = NiceNormal
  19         DefaultNiceFile = NiceBulk
  20 )
  21
  22 var (
  23         niceRe      *regexp.Regexp   = regexp.MustCompile(`^(\w+)([-+])(\d+)$`)
  24         niceAliases map[string]uint8 = map[string]uint8{
  25                 "flash":    NiceFlash,
  26                 "f":        NiceFlash,
  27                 "priority": NicePriority,
  28                 "p":        NicePriority,
  29                 "normal":   NiceNormal,
  30                 "n":        NiceNormal,
  31                 "bulk":     NiceBulk,
  32                 "b":        NiceBulk,
  33                 "max":      255,
  34         }
  35 )
  36
  37 func NicenessParse(s string) (uint8, error) {
  38         if nice, err := strconv.Atoi(s); err == nil {
  39                 if nice <= 0 || nice > 255 {
  40                         return 0, errors.New("nice out of bounds")
  41                 }
  42                 return uint8(nice), nil
  43         }
  44         s = strings.ToLower(s)
  45         var baseNice uint8
  46         var found bool
  47         if baseNice, found = niceAliases[s]; found {
  48                 return baseNice, nil
  49         }
  50         matches := niceRe.FindStringSubmatch(s)
  51         if len(matches) != 1+3 {
  52                 return 0, errors.New("invalid niceness")
  53         }
  54         baseNice, found = niceAliases[matches[1]]
  55         if !found {
  56                 return 0, errors.New("invalid niceness")
  57         }
  58         delta, err := strconv.Atoi(matches[3])
  59         if err != nil {
  60                 return 0, err
  61         }
  62         if matches[2] == "-" {
  63                 if delta > 31 {
  64                         return 0, errors.New("too big niceness delta")
  65                 }
  66                 return baseNice - uint8(delta), nil
  67         } else {
  68                 if delta > 32 || (baseNice == NiceBulk && delta > 31) {
  69                         return 0, errors.New("too big niceness delta")
  70                 }
  71                 return baseNice + uint8(delta), nil
  72         }
  73 }
  74
  75 func NicenessFmt(nice uint8) string {
  76         switch {
  77         case nice == 255:
  78                 return "MAX"
  79         case NiceFlash-31 < nice && nice < NiceFlash:
  80                 return fmt.Sprintf("F-%d", NiceFlash-nice)
  81         case nice == NiceFlash:
  82                 return "F"
  83         case NiceFlash < nice && nice <= (NiceFlash+32):
  84                 return fmt.Sprintf("F+%d", nice-NiceFlash)
  85
  86         case NicePriority-31 < nice && nice < NicePriority:
  87                 return fmt.Sprintf("P-%d", NicePriority-nice)
  88         case nice == NicePriority:
  89                 return "P"
  90         case NicePriority < nice && nice <= (NicePriority+32):
  91                 return fmt.Sprintf("P+%d", nice-NicePriority)
  92
  93         case NiceNormal-31 < nice && nice < NiceNormal:
  94                 return fmt.Sprintf("N-%d", NiceNormal-nice)
  95         case nice == NiceNormal:
  96                 return "N"
  97         case NiceNormal < nice && nice <= (NiceNormal+32):
  98                 return fmt.Sprintf("N+%d", nice-NiceNormal)
  99
 100         case NiceBulk-31 < nice && nice < NiceBulk:
 101                 return fmt.Sprintf("B-%d", NiceBulk-nice)
 102         case nice == NiceBulk:
 103                 return "B"
 104         case NiceBulk < nice && nice <= (NiceBulk+30):
 105                 return fmt.Sprintf("B+%d", nice-NiceBulk)
 106         }
 107         return strconv.Itoa(int(nice))
 108 }
 109
 110 type ByNice []*SPInfo
 111
 112 func (a ByNice) Len() int {
 113         return len(a)
 114 }
 115
 116 func (a ByNice) Swap(i, j int) {
 117         a[i], a[j] = a[j], a[i]
 118 }
 119
 120 func (a ByNice) Less(i, j int) bool {
 121         return a[i].Nice < a[j].Nice
 122 }