0001-thread.c-sleep_-reduce-the-effect-of-spurious-interr.patch - Ruby master - Ruby Issue Tracking System

signal.c
1039	1039	}
1040	1040	#endif
1041	1041
1042		static void
	1042	static int
1043	1043	signal_exec(VALUE cmd, int safe, int sig)
1044	1044	{
1045	1045	rb_execution_context_t *ec = GET_EC();
...	...
1053	1053	* 3. rb_signal_exec runs on queued signal
1054	1054	*/
1055	1055	if (IMMEDIATE_P(cmd))
1056		return;
	1056	return FALSE;
1057	1057
1058	1058	ec->interrupt_mask \|= TRAP_INTERRUPT_MASK;
1059	1059	EC_PUSH_TAG(ec);
...	...
1069	1069	/* XXX: should be replaced with rb_threadptr_pending_interrupt_enque() */
1070	1070	EC_JUMP_TAG(ec, state);
1071	1071	}
	1072	return TRUE;
1072	1073	}
1073	1074
1074	1075	void
...	...
1093	1094	}
1094	1095	}
1095	1096
1096		void
	1097	/* returns true if a trap handler was run, false otherwise */
	1098	int
1097	1099	rb_signal_exec(rb_thread_t *th, int sig)
1098	1100	{
1099	1101	rb_vm_t *vm = GET_VM();
...	...
1131	1133	rb_threadptr_signal_exit(th);
1132	1134	}
1133	1135	else {
1134		signal_exec(cmd, safe, sig);
	1136	return signal_exec(cmd, safe, sig);
1135	1137	}
	1138	return FALSE;
1136	1139	}
1137	1140
1138	1141	static sighandler_t

         }; \
     } while(0)
     /*
      * returns true if this thread was spuriously interrupted, false otherwise
      * (e.g. hit by Thread#run or ran a Ruby-level Signal.trap handler)
      */
     #define RUBY_VM_CHECK_INTS_BLOCKING(ec) vm_check_ints_blocking(ec)
     static inline void
     static inline int
     vm_check_ints_blocking(rb_execution_context_t *ec)
+    {
         rb_thread_t *th = rb_ec_thread_ptr(ec);
         if (LIKELY(rb_threadptr_pending_interrupt_empty_p(th))) {
     	if (LIKELY(!RUBY_VM_INTERRUPTED_ANY(ec))) return;
     	if (LIKELY(!RUBY_VM_INTERRUPTED_ANY(ec))) return FALSE;
+        }
         else {
     	th->pending_interrupt_queue_checked = 0;
     	RUBY_VM_SET_INTERRUPT(ec);
+        }
         rb_threadptr_execute_interrupts(th, 1);
         return rb_threadptr_execute_interrupts(th, 1);
+    }
     static int
-...
+    {
         enum rb_thread_status prev_status = th->status;
         enum rb_thread_status status;
         int woke;
         status  = fl & SLEEP_DEADLOCKABLE ? THREAD_STOPPED_FOREVER : THREAD_STOPPED;
         th->status = status;
-...
     	if (fl & SLEEP_DEADLOCKABLE) {
     	    th->vm->sleeper--;
+    	}
     	RUBY_VM_CHECK_INTS_BLOCKING(th->ec);
     	if (!(fl & SLEEP_SPURIOUS_CHECK))
     	woke = vm_check_ints_blocking(th->ec);
     	if (woke && !(fl & SLEEP_SPURIOUS_CHECK))
     	    break;
+        }
         th->status = prev_status;
-...
+    {
         struct timespec end;
         enum rb_thread_status prev_status = th->status;
         int woke;
         getclockofday(&end);
         timespec_add(&end, &ts);
-...
         RUBY_VM_CHECK_INTS_BLOCKING(th->ec);
         while (th->status == THREAD_STOPPED) {
     	native_sleep(th, &ts);
     	RUBY_VM_CHECK_INTS_BLOCKING(th->ec);
     	if (!(fl & SLEEP_SPURIOUS_CHECK))
     	woke = vm_check_ints_blocking(th->ec);
     	if (woke && !(fl & SLEEP_SPURIOUS_CHECK))
     	    break;
     	if (timespec_update_expire(&ts, &end))
     	    break;
-...
         return interrupt & (rb_atomic_t)~ec->interrupt_mask;
+    }
     MJIT_FUNC_EXPORTED void
     MJIT_FUNC_EXPORTED int
     rb_threadptr_execute_interrupts(rb_thread_t *th, int blocking_timing)
+    {
         rb_atomic_t interrupt;
         int postponed_job_interrupt = 0;
         int ret = FALSE;
         if (th->ec->raised_flag) return;
         if (th->ec->raised_flag) return ret;
         while ((interrupt = threadptr_get_interrupts(th)) != 0) {
     	int sig;
-...
+    	    }
     	    th->status = THREAD_RUNNABLE;
     	    while ((sig = rb_get_next_signal()) != 0) {
     		rb_signal_exec(th, sig);
     		ret |= rb_signal_exec(th, sig);
+    	    }
     	    th->status = prev_status;
+    	}
-...
     	if (pending_interrupt && threadptr_pending_interrupt_active_p(th)) {
     	    VALUE err = rb_threadptr_pending_interrupt_deque(th, blocking_timing ? INTERRUPT_ON_BLOCKING : INTERRUPT_NONE);
     	    thread_debug("rb_thread_execute_interrupts: %"PRIdVALUE"\n", err);
                 ret = TRUE;
     	    if (err == Qundef) {
     		/* no error */
-...
     	    rb_thread_schedule_limits(limits_us);
+    	}
+        }
         return ret;
+    }
     void

     VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt);
     int rb_signal_buff_size(void);
     void rb_signal_exec(rb_thread_t *th, int sig);
     int rb_signal_exec(rb_thread_t *th, int sig);
     void rb_threadptr_check_signal(rb_thread_t *mth);
     void rb_threadptr_signal_raise(rb_thread_t *th, int sig);
     void rb_threadptr_signal_exit(rb_thread_t *th);
     void rb_threadptr_execute_interrupts(rb_thread_t *, int);
     int rb_threadptr_execute_interrupts(rb_thread_t *, int);
     void rb_threadptr_interrupt(rb_thread_t *th);
     void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th);
     void rb_threadptr_pending_interrupt_clear(rb_thread_t *th);
+    -

Project

General

Profile

Ruby » Ruby master

Feature #15002 » 0001-thread.c-sleep_-reduce-the-effect-of-spurious-interr.patch