Add methods to get the ID of a std.os.Thread, and to get ID of current thread

[mdsteele]

Being able to get the current thread ID would be handy for various things. Here are two specific examples that are relevant to the project I'm working on at the moment:

• When implementing a mutex, you can store the ID of the locking thread to help detect deadlock where the same thread tries to lock it again, or to detect a different thread trying to unlock.
• When implementing a thread-safe allocator, you can map different threads to different subheaps to help avoid false sharing (note that a thread-local variable is unhelpful here, because a thread may sometimes need to access the subheap of another thread).

Strawman proposal for code in std/os/index.zig:

const ThreadId = usize; // or something else, possibly depending on builtin.os

pub const Thread = struct {
    // ...existing code...

    /// Returns the ID of this thread object.
    pub fn id(self: *const this) ThreadId {
        return if (use_pthreads) {
            self.data.handle
        } else switch (builtin.os) {
            builtin.Os.linux => @bitCast(u32, self.data.pid),
            builtin.Os.windows => @ptrToInt(self.data.handle),
            else => @compileError("Unsupported OS"),
        };
    }

    /// Returns the ID of the calling thread.
    pub fn current() ThreadId {
        return if (use_pthreads) {
            c.pthread_self()
        } else switch (builtin.os) {
            // ...etc... (if I knew how to do this part, I would've just sent a PR)
        };
    }
};

[mdsteele]

On a second look, I think I can try to put together a PR for this after all. (Also, the code above doesn't compile, so that needs some work...)

[andrewrk]

I think you can accomplish this in the places you need it (e.g. in your allocator code) with thread local storage (#924) like this:

var next_global_id: usize = 1;
threadlocal var thread_id: usize = 0;

fn getThreadId() usize {
     const id = thread_id;
     if (id != 0) return id;
     const allocated_id = @atomicRmw(usize, &next_global_id, AtomicRmwOp.Add, 1, AtomicOrder.SeqCst);
     thread_id = allocated_id;
     return allocated_id;
}

Every thread gets assigned a unique id, which you could use in your mutex or allocator use cases to distinguish.

This getThreadId function could be available in the standard library to use. What's nice about this is that:

• if no one uses it, it doesn't get compiled and the TLS variable is not necessary
• if many uses of it occur, they share the same implementation.