Source file src/pkg/cmd/vendor/golang.org/x/sys/unix/affinity_linux.go

     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	}
   125	

View as plain text