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         }
  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 func NicenessFmt(nice uint8) string {
  75         switch {
  76         case nice == 255:
  77                 return "MAX"
  78         case NiceFlash-31 < nice && nice < NiceFlash:
  79                 return fmt.Sprintf("F-%d", NiceFlash-nice)
  80         case nice == NiceFlash:
  81                 return "F"
  82         case NiceFlash < nice && nice <= (NiceFlash+32):
  83                 return fmt.Sprintf("F+%d", nice-NiceFlash)
  84
  85         case NicePriority-31 < nice && nice < NicePriority:
  86                 return fmt.Sprintf("P-%d", NicePriority-nice)
  87         case nice == NicePriority:
  88                 return "P"
  89         case NicePriority < nice && nice <= (NicePriority+32):
  90                 return fmt.Sprintf("P+%d", nice-NicePriority)
  91
  92         case NiceNormal-31 < nice && nice < NiceNormal:
  93                 return fmt.Sprintf("N-%d", NiceNormal-nice)
  94         case nice == NiceNormal:
  95                 return "N"
  96         case NiceNormal < nice && nice <= (NiceNormal+32):
  97                 return fmt.Sprintf("N+%d", nice-NiceNormal)
  98
  99         case NiceBulk-31 < nice && nice < NiceBulk:
 100                 return fmt.Sprintf("B-%d", NiceBulk-nice)
 101         case nice == NiceBulk:
 102                 return "B"
 103         case NiceBulk < nice && nice <= (NiceBulk+30):
 104                 return fmt.Sprintf("B+%d", nice-NiceBulk)
 105         }
 106         return strconv.Itoa(int(nice))
 107 }
 108
 109 type ByNice []*SPInfo
 110
 111 func (a ByNice) Len() int {
 112         return len(a)
 113 }
 114
 115 func (a ByNice) Swap(i, j int) {
 116         a[i], a[j] = a[j], a[i]
 117 }
 118
 119 func (a ByNice) Less(i, j int) bool {
 120         return a[i].Nice < a[j].Nice
 121 }