Add thread pool example

[karl-zylinski]

Showcase a simple but idiomatic use case for thread pools with comments about what everything does.

[NilOmniscient]

Something like this? I'm pretty new to Odin, literally learned it 2 days ago, so I'm not sure how idiomatic this is.

Edit: Hmm, the markdown in the comment is doing odd things. I did try to enclose it in the code tag.

`
package threadpool_example

import "core:fmt"
import "core:math"
import "core:mem"
import "core:mem/virtual"
import "core:os"
import "core:time"
import "core:thread"

// How many tasks to perform.
ITER : u64 : 1000000

ThreadPayload :: struct {
beg: u64,
end: u64,
results: ^[]f64
}

main :: proc() {
// Zero init the thread pool
pool: thread.Pool

// Create our output
results: []f64 = make([]f64, ITER)

// Here, we're just getting the number of CPU cores to decide how many threads to create. 
num_cpus := os.processor_core_count()

// Now properly init the pool and get it spooled up
thread.pool_init(&pool, context.allocator, num_cpus)
thread.pool_start(&pool)
// Defer the destruction so that it gets cleaned up when it's no longer necessary
defer thread.pool_destroy(&pool)

// Create the allocator
client_arena :virtual.Arena
arena_allocator_error := virtual.arena_init_growing(&client_arena, 1*mem.Byte)
// TODO: Handle the error. 
client_allocator := virtual.arena_allocator(&client_arena)

// Now that there's an allocator, we can start spinning up tasks. 
remaining: u64 = ITER
per_task: u64 = ITER / cast(u64)num_cpus
begin: u64 = 0
index: int = 0
// Let's get a benchmark time started for the work loop. To benchmark the entire process, move this up to the top. 
start := time.now()
for remaining > 0 {
    // Use min to prevent overflows
    to_process: u64 = math.min(per_task, remaining)
    // Create and populate the payload. 
    payload, allocator_error := new(ThreadPayload, client_allocator)
    // TODO: Handle errors. 
    payload.beg = begin
    payload.end = begin + to_process
    payload.results = &results
    // Add the payload and worker to the task list. 
    thread.pool_add_task(&pool, client_allocator, thread_work, payload, index)
    begin += to_process
    remaining -= to_process
    index += 1
}
// Wait for the thread pool to finish. 
thread.pool_finish(&pool)

// Pool is now free to start/launch other tasks

end := time.now()
elapsed := time.duration_nanoseconds(time.diff(start, end))
// Ok, work's done. If you want to see the full results, uncomment below. But this takes longer than the threaded work does.
//fmt.println("Work complete. Results: ", results)

// Otherwise, just print the first and last elements. Since it's just sin(i) * cos(i), it should be predictable. 
fmt.println("First element: ", results[0])
fmt.println("Last element: ", results[ITER-1])
fmt.println("Time elapsed: ", elapsed, " nanoseconds")
return

}

// Worker functions get passed a Task object
thread_work :: proc(task: thread.Task) {
// The data inside the task is a rawptr, need to cast it to something readable
payload := cast(^ThreadPayload)task.data

// Do our work. 
for i: u64 = payload.beg; i < payload.end; i += 1 {
    payload.results[i] = math.sin(cast(f64)i) * math.cos(cast(f64)i)
}
return

}
`