core:thread get_name/set_name

core/sys/posix/pthread.odin

@@ -5,7 +5,7 @@ import "core:c"
 
 when ODIN_OS == .Darwin {
 	foreign import lib "system:System"
-} else when ODIN_OS == .FreeBSD || ODIN_OS == .NetBSD || ODIN_OS == .Linux {
+} else when ODIN_OS == .FreeBSD || ODIN_OS == .NetBSD || ODIN_OS == .Linux || ODIN_OS == .OpenBSD {
 	foreign import lib "system:pthread"
 } else {
 	foreign import lib "system:c"

core/sys/windows/kernel32.odin

@@ -168,7 +168,7 @@ foreign kernel32 {
 	ResumeThread :: proc(thread: HANDLE) -> DWORD ---
 	GetThreadPriority :: proc(thread: HANDLE) -> c_int ---
 	SetThreadPriority :: proc(thread: HANDLE, priority: c_int) -> BOOL ---
-	GetThreadDescription :: proc(hThread: HANDLE, ppszThreadDescription: ^PCWSTR) -> HRESULT ---
+	GetThreadDescription :: proc(hThread: HANDLE, ppszThreadDescription: ^PWSTR) -> HRESULT ---
 	SetThreadDescription :: proc(hThread: HANDLE, lpThreadDescription: PCWSTR) -> HRESULT ---
 	GetExitCodeThread :: proc(thread: HANDLE, exit_code: ^DWORD) -> BOOL ---
 	TerminateThread :: proc(thread: HANDLE, exit_code: DWORD) -> BOOL ---

core/thread/thread_name_darwin.odin

@@ -0,0 +1,13 @@
+#+build darwin
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+foreign import pthread "system:System.framework"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(name: [^]u8) -> posix.Errno ---
+}

core/thread/thread_name_freebsd.odin

@@ -0,0 +1,13 @@
+#+build freebsd
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+foreign import pthread "system:pthread"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(thread: posix.pthread_t, name: [^]u8) -> posix.Errno ---
+}

core/thread/thread_name_linux.odin

@@ -0,0 +1,13 @@
+#+build linux
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+foreign import pthread "system:pthread"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(thread: posix.pthread_t, name: [^]u8) -> posix.Errno ---
+}

core/thread/thread_name_netbsd.odin

@@ -0,0 +1,13 @@
+#+build netbsd
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+foreign import pthread "system:pthread"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(thread: posix.pthread_t, name: cstring, arg: rawptr) -> posix.Errno ---
+}

core/thread/thread_name_openbsd.odin

@@ -0,0 +1,13 @@
+#+build openbsd
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+foreign import pthread "system:pthread"
+
+foreign pthread {
+	pthread_get_name_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) ---
+	pthread_set_name_np :: proc(thread: posix.pthread_t, name: [^]u8) ---
+}

core/thread/thread_other.odin

@@ -2,6 +2,7 @@
 package thread
 
 import "base:intrinsics"
+import "base:runtime"
 
 _IS_SUPPORTED :: false
 
@@ -13,7 +14,7 @@ _thread_priority_map := [Thread_Priority]i32{
 	.High = +2,
 }
 
-_create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^Thread {
+_create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal, name: Maybe(string) = nil) -> ^Thread {
 	unimplemented("core:thread procedure not supported on target")
 }
 
@@ -45,3 +46,10 @@ _yield :: proc() {
 	unimplemented("core:thread procedure not supported on target")
 }
 
+_get_name :: proc(thread: ^Thread, allocator : runtime.Allocator, loc : runtime.Source_Code_Location) -> (string, runtime.Allocator_Error) {
+	unimplemented("core:thread procedure not supported on this target")
+}
+
+_set_name :: proc(thread: ^Thread, name:string) {
+	unimplemented("core:thread procedure not supported on this target")
+}

core/thread/thread_unix.odin

@@ -5,9 +5,10 @@ package thread
 import "base:runtime"
 import "core:sync"
 import "core:sys/posix"
+import "core:strings"
 
 _IS_SUPPORTED :: true
-
+_MAX_PTHREAD_NAME_LENGTH :: 16
 // NOTE(tetra): Aligned here because of core/unix/pthread_linux.odin/pthread_t.
 // Also see core/sys/darwin/mach_darwin.odin/semaphore_t.
 Thread_Os_Specific :: struct #align(16) {
@@ -18,7 +19,7 @@ Thread_Os_Specific :: struct #align(16) {
 // Creates a thread which will run the given procedure.
 // It then waits for `start` to be called.
 //
-_create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
+_create :: proc(procedure: Thread_Proc, priority: Thread_Priority, name: Maybe(string)) -> ^Thread {
 	__unix_thread_entry_proc :: proc "c" (t: rawptr) -> rawptr {
 		t := (^Thread)(t)
 
@@ -57,6 +58,10 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 				runtime.run_thread_local_cleaners()
 			}
 
+			when ODIN_OS != .Haiku {
+				_set_name(t)
+			}
+
 			t.procedure(t)
 		}
 
@@ -125,6 +130,9 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 		free(thread, thread.creation_allocator)
 		return nil
 	}
+
+	thread.name = name
+
 	return thread
 }
 
@@ -187,3 +195,58 @@ _terminate :: proc(t: ^Thread, exit_code: int) {
 _yield :: proc() {
 	posix.sched_yield()
 }
+
+_get_name :: proc(thread: ^Thread, allocator: runtime.Allocator, loc: runtime.Source_Code_Location) -> (name: string, err: runtime.Allocator_Error) {
+	// Haiku doesn't have pthread_getname yet
+	when ODIN_OS == .Haiku {
+		unimplemented("core:thread get_name for haiku is not yet supported")
+	}
+
+	tid: posix.pthread_t
+	if thread == nil {
+		tid = posix.pthread_self()
+	} else {
+		tid = thread.unix_thread
+	}
+
+	buf := make([]u8, _MAX_PTHREAD_NAME_LENGTH, allocator, loc) or_return
+
+	when ODIN_OS == .Darwin || ODIN_OS == .Linux || ODIN_OS == .FreeBSD || ODIN_OS == .NetBSD {
+		pthread_getname_np(tid, raw_data(buf), len(buf))
+	} else when ODIN_OS == .OpenBSD {
+		pthread_get_name_np(tid, raw_data(buf), len(buf))
+	}
+
+	name = transmute(string)buf
+	name = strings.truncate_to_byte(name, 0)
+
+	return
+}
+
+_set_name :: proc(thread: ^Thread) {
+	name, ok := thread.name.?
+	if !ok {
+		return
+	}
+
+	when ODIN_OS != .Darwin {
+		tid := thread.unix_thread
+	}
+
+	buf: [_MAX_PTHREAD_NAME_LENGTH]u8
+	copy(buf[:], name)
+
+	// _MAX_PTHREAD_NAME_LENGTH includes terminating null
+	buf[len(buf) - 1] = 0
+
+	when ODIN_OS == .Darwin {
+		pthread_setname_np(raw_data(buf[:]))
+	} else when ODIN_OS == .OpenBSD {
+		pthread_set_name_np(tid, raw_data(buf[:]))
+	} else when ODIN_OS == .NetBSD {
+		pthread_setname_np(tid, "%s", raw_data(buf[:]))
+	} else {
+		pthread_setname_np(tid, raw_data(buf[:]))
+	}
+
+}

core/thread/thread_windows.odin

@@ -6,8 +6,11 @@ import "base:intrinsics"
 import "base:runtime"
 import "core:sync"
 import win32 "core:sys/windows"
+import "core:unicode/utf16"
 
 _IS_SUPPORTED :: true
+//NOTE(peperronii): not sure about the exact length but there must be a limit
+_THREAD_DESCRIPTION_LENGTH :: 128
 
 Thread_Os_Specific :: struct {
 	win32_thread:    win32.HANDLE,
@@ -22,7 +25,7 @@ _thread_priority_map := [Thread_Priority]i32{
 	.High = +2,
 }
 
-_create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
+_create :: proc(procedure: Thread_Proc, priority: Thread_Priority, name: Maybe(string)) -> ^Thread {
 	win32_thread_id: win32.DWORD
 
 	__windows_thread_entry_proc :: proc "system" (t_: rawptr) -> win32.DWORD {
@@ -44,6 +47,8 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 				runtime.run_thread_local_cleaners()
 			}
 
+			_set_name(t)
+
 			t.procedure(t)
 		}
 
@@ -76,6 +81,7 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 	thread.win32_thread    = win32_thread
 	thread.win32_thread_id = win32_thread_id
 	thread.id              = int(win32_thread_id)
+	thread.name            = name
 
 	ok := win32.SetThreadPriority(win32_thread, _thread_priority_map[priority])
 	assert(ok == true)
@@ -152,3 +158,33 @@ _yield :: proc() {
 	win32.SwitchToThread()
 }
 
+_get_name :: proc(thread: ^Thread, allocator: runtime.Allocator, loc: runtime.Source_Code_Location) -> (name: string, err: runtime.Allocator_Error) {
+	t_handle: win32.HANDLE
+	if thread == nil {
+		t_handle = win32.GetCurrentThread()
+	} else {
+		t_handle = thread.win32_thread
+	}
+
+	buf_16: win32.PWSTR
+	win32.GetThreadDescription(t_handle, &buf_16)
+	name = win32.wstring_to_utf8(buf_16, -1, allocator) or_return
+	win32.LocalFree(rawptr(buf_16))
+
+	return
+}
+
+_set_name :: proc(thread: ^Thread) {
+	name, ok := thread.name.?
+	if !ok {
+		return
+	}
+
+	t_handle := thread.win32_thread
+
+	buf: [_THREAD_DESCRIPTION_LENGTH]u16
+	// _THREAD_DESCRIPTION_LENGTH includes terminating null
+	utf16.encode_string(buf[:len(buf) - 1], name)
+	win32.SetThreadDescription(t_handle, raw_data(buf[:]))
+}
+