"Fossies" - the Fresh Open Source Software Archive

Member "buildah-1.23.1/tests/tools/vendor/golang.org/x/sys/unix/affinity_linux.go" (28 Sep 2021, 3277 Bytes) of package /linux/misc/buildah-1.23.1.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 // Copyright 2018 The Go Authors. All rights reserved.
    2 // Use of this source code is governed by a BSD-style
    3 // license that can be found in the LICENSE file.
    4 
    5 // CPU affinity functions
    6 
    7 package unix
    8 
    9 import (
   10     "unsafe"
   11 )
   12 
   13 const cpuSetSize = _CPU_SETSIZE / _NCPUBITS
   14 
   15 // CPUSet represents a CPU affinity mask.
   16 type CPUSet [cpuSetSize]cpuMask
   17 
   18 func schedAffinity(trap uintptr, pid int, set *CPUSet) error {
   19     _, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set)))
   20     if e != 0 {
   21         return errnoErr(e)
   22     }
   23     return nil
   24 }
   25 
   26 // SchedGetaffinity gets the CPU affinity mask of the thread specified by pid.
   27 // If pid is 0 the calling thread is used.
   28 func SchedGetaffinity(pid int, set *CPUSet) error {
   29     return schedAffinity(SYS_SCHED_GETAFFINITY, pid, set)
   30 }
   31 
   32 // SchedSetaffinity sets the CPU affinity mask of the thread specified by pid.
   33 // If pid is 0 the calling thread is used.
   34 func SchedSetaffinity(pid int, set *CPUSet) error {
   35     return schedAffinity(SYS_SCHED_SETAFFINITY, pid, set)
   36 }
   37 
   38 // Zero clears the set s, so that it contains no CPUs.
   39 func (s *CPUSet) Zero() {
   40     for i := range s {
   41         s[i] = 0
   42     }
   43 }
   44 
   45 func cpuBitsIndex(cpu int) int {
   46     return cpu / _NCPUBITS
   47 }
   48 
   49 func cpuBitsMask(cpu int) cpuMask {
   50     return cpuMask(1 << (uint(cpu) % _NCPUBITS))
   51 }
   52 
   53 // Set adds cpu to the set s.
   54 func (s *CPUSet) Set(cpu int) {
   55     i := cpuBitsIndex(cpu)
   56     if i < len(s) {
   57         s[i] |= cpuBitsMask(cpu)
   58     }
   59 }
   60 
   61 // Clear removes cpu from the set s.
   62 func (s *CPUSet) Clear(cpu int) {
   63     i := cpuBitsIndex(cpu)
   64     if i < len(s) {
   65         s[i] &^= cpuBitsMask(cpu)
   66     }
   67 }
   68 
   69 // IsSet reports whether cpu is in the set s.
   70 func (s *CPUSet) IsSet(cpu int) bool {
   71     i := cpuBitsIndex(cpu)
   72     if i < len(s) {
   73         return s[i]&cpuBitsMask(cpu) != 0
   74     }
   75     return false
   76 }
   77 
   78 // Count returns the number of CPUs in the set s.
   79 func (s *CPUSet) Count() int {
   80     c := 0
   81     for _, b := range s {
   82         c += onesCount64(uint64(b))
   83     }
   84     return c
   85 }
   86 
   87 // onesCount64 is a copy of Go 1.9's math/bits.OnesCount64.
   88 // Once this package can require Go 1.9, we can delete this
   89 // and update the caller to use bits.OnesCount64.
   90 func onesCount64(x uint64) int {
   91     const m0 = 0x5555555555555555 // 01010101 ...
   92     const m1 = 0x3333333333333333 // 00110011 ...
   93     const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
   94     const m3 = 0x00ff00ff00ff00ff // etc.
   95     const m4 = 0x0000ffff0000ffff
   96 
   97     // Implementation: Parallel summing of adjacent bits.
   98     // See "Hacker's Delight", Chap. 5: Counting Bits.
   99     // The following pattern shows the general approach:
  100     //
  101     //   x = x>>1&(m0&m) + x&(m0&m)
  102     //   x = x>>2&(m1&m) + x&(m1&m)
  103     //   x = x>>4&(m2&m) + x&(m2&m)
  104     //   x = x>>8&(m3&m) + x&(m3&m)
  105     //   x = x>>16&(m4&m) + x&(m4&m)
  106     //   x = x>>32&(m5&m) + x&(m5&m)
  107     //   return int(x)
  108     //
  109     // Masking (& operations) can be left away when there's no
  110     // danger that a field's sum will carry over into the next
  111     // field: Since the result cannot be > 64, 8 bits is enough
  112     // and we can ignore the masks for the shifts by 8 and up.
  113     // Per "Hacker's Delight", the first line can be simplified
  114     // more, but it saves at best one instruction, so we leave
  115     // it alone for clarity.
  116     const m = 1<<64 - 1
  117     x = x>>1&(m0&m) + x&(m0&m)
  118     x = x>>2&(m1&m) + x&(m1&m)
  119     x = (x>>4 + x) & (m2 & m)
  120     x += x >> 8
  121     x += x >> 16
  122     x += x >> 32
  123     return int(x) & (1<<7 - 1)
  124 }