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