func pinToCPU(cpu uint) error {
    const __NR_sched_setaffinity = 203
    var mask [1024 / 64]uint8
    runtime.LockOSThread()
    mask[cpu / 64] |= 1 << (cpu % 64)
    _, _, errno := syscall.RawSyscall(__NR_sched_setaffinity, 0, uintptr(len(mask) * 8), uintptr(unsafe.Pointer(&mask)))
    if errno != 0 {
        return errno
    }
    return nil
}

// pinToCPU pin the pid to CPU index,
// usually, pid is a outside/standalone process(no write in Go) 
func pinToCPU(pid int, cpu uint) error {
    const __NR_sched_setaffinity = 203
    var mask [1024 / 64]uint8
    runtime.LockOSThread()
    defer runtime.UnlockOSThread()
    mask[cpu/64] |= 1 << (cpu % 64)
    _, _, errno := syscall.RawSyscall(__NR_sched_setaffinity, uintptr(pid), uintptr(len(mask)*8), uintptr(unsafe.Pointer(&mask)))
    if errno != 0 {
        return errno
    }
    return nil
}

package main

import "os/exec"

func main() {
    // exe a program to run on cpu 0, 1, 2
    cmd := &exec.Cmd{
        Path: "/usr/bin/stress",
        SysProcAttr: &syscall.SysProcAttr{
            Affinitys: []int{0, 1, 2},
        },
    }
    err := cmd.Start()
    if err != nil {
        panic(err.Error())
    }
    cmd.Wait()
}

--- src/syscall/exec_linux.go.orig
+++ src/syscall/exec_linux.go
@@ -19,6 +19,7 @@
 }

 type SysProcAttr struct {
+   Affinitys   []int          // CPU affinitys.
    Chroot      string         // Chroot.
    Credential  *Credential    // Credential.
    Ptrace      bool           // Enable tracing.
@@ -44,6 +45,71 @@
 func runtime_BeforeFork()
 func runtime_AfterFork()

+const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const
+
+// GetAffinity return cpu list of pid
+func GetAffinity(pid uintptr) ([]int, error) {
+   var mask [1024 / 64]uintptr
+   var ret = make([]int, 0)
+   if pid <= 0 {
+       pid, _, _ = RawSyscall(SYS_GETPID, 0, 0, 0)
+   }
+   // size of uintptr is 8, in amd64
+   v1, _, err := RawSyscall(SYS_SCHED_GETAFFINITY, pid, uintptr(len(mask)*8), uintptr(unsafe.Pointer(&mask[0])))
+   if err != 0 {
+       return ret, err
+   }
+   nmask := mask[:v1/ptrSize]
+   idx := 0
+   for _, v := range nmask {
+       for i := 0; i < 64; i++ {
+           ct := int32(v & 1)
+           v >>= 1
+           if ct > 0 {
+               ret = append(ret, idx)
+           }
+           idx++
+       }
+   }
+   return ret, nil
+}
+
+// SetAffinity attend the cpu list to pid,
+// note: SetAffinity apply to thread ID only,
+// to fully control one process, call SetAffinity for all thread of the process.
+// use os.GetThreadIDs() to get all thread of the process
+func SetAffinity(pid uintptr, cpus []int) error {
+   var mask [1024 / 64]uintptr
+   if pid <= 0 {
+       pid, _, _ = RawSyscall(SYS_GETPID, 0, 0, 0)
+   }
+   for _, cpuIdx := range cpus {
+       cpuIndex := uint(cpuIdx)
+       mask[cpuIndex/64] |= 1 << (cpuIndex % 64)
+   }
+   _, _, err := RawSyscall(SYS_SCHED_SETAFFINITY, pid, uintptr(len(mask)*8), uintptr(unsafe.Pointer(&mask[0])))
+   if err != 0 {
+       return err
+   }
+   return nil
+}
+
+// AddAffinity attend one cpu to list of pid
+// note: AddAffinity apply to thread ID only,
+// to fully control one process, call SetAffinity for all thread of the process
+// use os.GetThreadIDs() to get all thread of the process
+func AddAffinity(pid uintptr, cpuIdx int) error {
+   if pid <= 0 {
+       pid, _, _ = RawSyscall(SYS_GETPID, 0, 0, 0)
+   }
+   cpus, e1 := GetAffinity(pid)
+   if e1 != nil {
+       return e1
+   }
+   cpus = append(cpus, cpuIdx)
+   return SetAffinity(pid, cpus)
+}
+
 // Fork, dup fd onto 0..len(fd), and exec(argv0, argvv, envv) in child.
 // If a dup or exec fails, write the errno error to pipe.
 // (Pipe is close-on-exec so if exec succeeds, it will be closed.)
@@ -63,6 +129,7 @@
        nextfd int
        i      int
        p      [2]int
+       mask   [1024 / 64]uintptr
    )

    // Record parent PID so child can test if it has died.
@@ -117,6 +184,19 @@
    }

    // Fork succeeded, now in child.
+
+   // setup cpu affinity when required
+   if sys.Affinitys != nil {
+       upid, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
+       for _, cpuIdx := range sys.Affinitys {
+           cpuIndex := uint(cpuIdx)
+           mask[cpuIndex/64] |= 1 << (cpuIndex % 64)
+       }
+       _, _, err1 = RawSyscall(SYS_SCHED_SETAFFINITY, upid, uintptr(len(mask)*8), uintptr(unsafe.Pointer(&mask[0])))
+       if err1 != 0 {
+           goto childerror
+       }
+   }

    // Wait for User ID/Group ID mappings to be written.
    if sys.UidMappings != nil || sys.GidMappings != nil {