Thread Mist

luikore

About Me

精通各种…​ 喜 各种hello world, 欢 …​ 彩虹小马和什么 GUI, 钻研各种…​ 虚拟机编译器和, 有空就写一个…​ 跳票多年的编辑器

@luikore

Odigo

https://www.odigo.travel

Threads

Theory

Practice

Threads are Hard

mutex futex condvar semaphore deadlock, livelock…​

Questions

No "TRUE" threads in Ruby? GIL is bad?

Remove Threads?

Remove Threads?

Celluloid! Fiber! CSP! pi-calculus!

But…​

Thread is what we have from OS or C

Threads are working great in…​

And…​

Thread Multiplexing Libraries

I18n.locale Mongoid query cache …​

And…​

System provides threads OS optimize threads over years Preemptive scheduling is a need

So let’s look deep down how threads schedule.

Glossary

CRuby = MRI yield GVL = GIL lock, mutex, spin lock condvar time slice

Threads Scheduling

Green Threads

Ruby < = 1.8 comes with green threads Blocking IO (read/write) blocks other threads

Native Threads

Introduced in Ruby 1.9 Very same implementation as green threads at first

Experiment

Let’s check a simple program

ruby -e 'gets'

Experiment

Timer Thread

There is one thread that not visible in Ruby program, which schedules other threads.

Why Timer?

Supervisor Ensure threads run "Fairly"

Timer Overview

We are Going Down…​

When does timer initialized?

What does timer thread actually do?

static void timer_thread_function(void *arg) {

rb_vm_t *vm = GET_VM(); native_mutex_lock(&vm->thread_destruct_lock); if (vm->running_thread)

ATOMIC_OR(vm->running_thread->interrupt_flag, TIMER_INTERRUPT_MAS native_mutex_unlock(&vm->thread_destruct_lock); }

What other thread does in safe-points?

if ((th)->interrupt_flag & ~(th)->interrupt_mask) { rb_threadptr_execute_interrupts();

}

What are safe-points?

Returning from a function …​

What is "execute interrupts"?

void rb_threadptr_execute_interrupts() {

timer_interrupt = interrupt & TIMER_INTERRUPT_MASK; ... if (timer_interrupt) {

... th->running_time_us += runnint_time_us; ... rb_thread_schedule_limits(limits_us); } }

What does "schedule limits" do?

static void rb_thread_schedule_limits(unsigned long limits_us) {

... if (th->running_time_us >= limits_us) {

RB_GC_SAVE_MACHINE_CONTEXT(th); gvl_yield(th->vm, th); // release and compete GVL } }

What does the GVL look like?

typedef struct rb_global_vm_lock_struct { /* fast path */ unsigned long acquired; rb_nativethread_lock_t lock;

/* slow path */ volatile unsigned long waiting; rb_nativethread_cond_t cond;

/* yield */ rb_nativethread_cond_t switch_cond; rb_nativethread_cond_t switch_wait_cond; int need_yield; int wait_yield; } rb_global_vm_lock_t;

What is gvl_yield?

native_mutex_lock(&vm->gvl.lock); gvl_release_common(vm); native_mutex_unlock(&vm->gvl.lock);

... sched_yield(); ...

native_mutex_lock(&vm->gvl.lock); native_cond_broadcast(&vm->gvl.switch_wait_cond); gvl_acquire_common(vm); native_mutex_unlock(&vm->gvl.lock);

What is gvl_release_common?

vm->gvl.acquired = 0; if (vm->gvl.waiting > 0)

native_cond_signal(&vm->gvl.cond);

What is gvl_acquire_common?

while(vm->gvl.acquired) { native_cond_wait(&vm->gvl.cond, &vm->gvl.lock);

}

What does sched_yield come from?

OS call to put current thread to lowest priority Think about Fiber.yield

Condvars

rb_nativethread_cond_t represent condition variables.

Condition variable can wait and release a mutex until some condition is met.

Condvars

Resource Consumer

# pseudo code lock(mutex) while cond

wait(condvar, mutex) end unlock(mutex)

Condvars

Resource Producer

pthread_cond_signal(condvar) pthread_cond_broadcast(condvar)

Conclusion

Threads are preemptive…​right? Ruby threads are cooperative too…​

What GIL Guarantees

Standalone C functions are "atomic" in MRI Easy for writing C extensions Release GIL when you know you are going into a "blocking region"

Blocking Region

VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, {

... th->waiting_fd = fd; ... BLOCKING_REGION({

val = func(data1); saved_errno = errno; }, ubf_select, th, FALSE); }

Blocking Region (2)

What BLOCKING_REGION macro does

RB_GC_SAVE_MACHINE_CONTEXT(th); gvl_release(th->vm); ... // do your blocking work! gvl_acquire(th->vm, th);

A "blocking work" is a call that may sleep current thread and woke up later.

Blocking Calls

accept—accept an incoming connection read—read some data from a socket or file select—choose available file descriptors poll—simpler select epoll—inverse control, wake up by OS kevent—the kqueue version of epoll …​many more

Blocking Calls

Costs a lot of CPU, or cost an unknown amount of time

Optimization

Regarding the threads with GIL

Parallelism?

Don’t Use Threads For Parallelism

It is slower …​

a = 1..20 b = 1..20 asum, bsum = 0, 0 t = Thread.new{ asum = a.inject :+ } bsum = b.inject :+ t.join puts asum + bsum

Parallelism?

Just:

a.inject(:+) + b.inject(:+)

Choose # of Threads

Too many: time wasted in context switching Too few: users have to wait in a queue while your CPU io-waits

Reduce Thread Stack Size

less Middleware MVC

Manually Release GVL

Already used in zlib, so ruby multi-thread spiders can utilize up to 2 cores

gvl_release(th) ... // you know that code doesn't affect Ruby gvl_acquire(th)

When It’s not Ruby’s Fault…​

IO: your Bottle Neck

100.times do Comment.create post: post, "rabbit #{rand}"

end

Batch: Reduce IO Latency

Simple way to batch SQL—transaction

transaction do 100.times do Comment.create post: post, "rabbit #{rand}" end

end

IO is Everywhere…​

NUMA abstracts memory visits DMA reduces memory copying Sharing between APU and FPU Sharing between LLC and main memory Sharing between CPU and GPU …​

Connection Pool Limit

Some long jobs took too long to finish, exhausting the connection pool, then blocked other threads…​

Manually Release Connection

Release it manually before starting something that takes a long time:

# in rails action or sidekiq job ActiveRecord::Base.clear_active_connections! Net::HTTP.get 'http://example.com'

Removing GIL

JVM and Rubinius posses no GIL…​How?

Fine Grained Locks

Problem: Very complex VM—50+ Locks!

Use HTM instead

Hardware transactional memory "Spinlock" Problem: different usage for different hardware platforms and compilers

Thread-safe Data Structures

Problem: slower single threaded code

Concurrent GC

GC must make sure mark/sweep Problem: slower single threaded code

Thread-safe Extensions

Simple solution: still acquire GVL when calling nonthread-safe cfunc

Long Long Way to Go

Removing threads is actually easier:

Ref

http://www.jstorimer.com/blogs/workingwithcode/8100871understands-the-gil-part-2-implementation http://www.cs.fsu.edu/~baker/realtime/restricted/notes/prodc