Spider - further work reducing surface area of time functions

samaaron · samaaron · commit f0993208fce1 · 2021-08-09T22:40:23.000+01:00
All Time Management functions have now been gathered and grouped to a small section at the top of runtime.rb.

Note that all the thread locals in this block of fns are *only used within this fns* and not elsewhere. This includes both reading (get) and writing (set).

This should with the integration of Link support and for a global metronome.
diff --git a/app/server/ruby/lib/sonicpi/lang/core.rb b/app/server/ruby/lib/sonicpi/lang/core.rb
@@ -298,7 +298,7 @@ def get_event(*args)
           # If we've time_warped into the future raise a timing exception
           if __system_thread_locals.get(:sonic_pi_spider_in_time_warp)
 
-            if __system_thread_locals.get(:sonic_pi_spider_time_warp_start) < __system_thread_locals.get(:sonic_pi_spider_time)
+            if __system_thread_locals.get(:sonic_pi_spider_time_warp_start) < __get_spider_time
               raise TimingError, "Sadly, you may not time_warp into the future to call get, then bring the result back in time to now."
             end
           end
@@ -939,7 +939,6 @@ def clear
       def time_warp(times=0, params=nil, &block)
         __schedule_delayed_blocks_and_messages!
 
-
         raise ArgumentError, "time_warp requires a do/end block" unless block
         prev_ctl_deltas = __system_thread_locals.get(:sonic_pi_local_control_deltas)
         prev_cache = __system_thread_locals.get(:sonic_pi_spider_time_state_cache, [])
@@ -953,45 +952,37 @@ def time_warp(times=0, params=nil, &block)
         raise ArgumentError, "params needs to be a list-like thing" unless params.respond_to? :[]
         raise ArgumentError, "times needs to be a list-like thing" unless times.respond_to? :each_with_index
 
-        vt_orig = __get_spider_time
-        density = __thread_locals.get(:sonic_pi_local_spider_density) || 1.0
-        orig_sleep_mul_w_density = __get_spider_sleep_mul * density
-        orig_beat = __get_spider_beat
+
         already_in_time_warp = __system_thread_locals.get :sonic_pi_spider_in_time_warp
 
-        __system_thread_locals.set(:sonic_pi_spider_time_warp_start, vt_orig.freeze) unless  already_in_time_warp
+        __system_thread_locals.set(:sonic_pi_spider_time_warp_start, __get_spider_time) unless  already_in_time_warp
         __system_thread_locals.set_local :sonic_pi_spider_in_time_warp, true
+        __with_preserved_spider_time_and_beat do
 
-        times.each_with_index do |delta, idx|
-          sleep_time = delta * orig_sleep_mul_w_density
-          new_time = vt_orig + sleep_time
+          times.each_with_index do |delta, idx|
 
-          __change_spider_time!(new_time)
-          __change_spider_beat!(orig_beat + delta)
-          __system_thread_locals.set_local :sonic_pi_local_control_deltas, {}
-          __system_thread_locals.set_local(:sonic_pi_spider_time_state_cache, [])
+            sleep delta
 
-          case block.arity
-          when 0
-            block.call
-          when 1
-            block.call(params[idx % params_size])
-          when 2
-            if had_params
-              block.call(delta, params[idx % params_size])
+            case block.arity
+            when 0
+              block.call
+            when 1
+              block.call(params[idx % params_size])
+            when 2
+              if had_params
+                block.call(delta, params[idx % params_size])
+              else
+                block.call(delta, idx)
+              end
+            when 3
+              block.call(t, params[idx % params_size], idx)
             else
-              block.call(delta, idx)
+              raise ArgumentError, "block for time_warp should only accept 0, 1, 2 or 3 parameters. You gave: #{block.arity}."
             end
-          when 3
-            block.call(t, params[idx % params_size], idx)
-          else
-            raise ArgumentError, "block for time_warp should only accept 0, 1, 2 or 3 parameters. You gave: #{block.arity}."
+            __schedule_delayed_blocks_and_messages!
           end
-          __schedule_delayed_blocks_and_messages!
         end
 
-        __change_spider_time!(vt_orig)
-        __change_spider_beat!(orig_beat)
         __system_thread_locals.set_local :sonic_pi_spider_in_time_warp, already_in_time_warp
         __system_thread_locals.set_local :sonic_pi_local_control_deltas, prev_ctl_deltas
         __system_thread_locals.set_local(:sonic_pi_spider_time_state_cache, prev_cache)
@@ -3573,8 +3564,7 @@ def with_cue_logging(v, &block)
       def use_bpm(bpm, &block)
         raise ArgumentError, "use_bpm does not work with a block. Perhaps you meant with_bpm" if block
         raise ArgumentError, "use_bpm's BPM should be a positive value. You tried to use: #{bpm}" unless bpm > 0
-        sleep_mul = 60.0 / bpm
-        __change_spider_sleep_mul!(sleep_mul)
+        __change_spider_bpm!(bpm)
       end
       doc name:           :use_bpm,
           introduced:     Version.new(2,0,0),
@@ -3627,11 +3617,10 @@ def use_bpm(bpm, &block)
       def with_bpm(bpm, &block)
         raise ArgumentError, "with_bpm must be called with a do/end block. Perhaps you meant use_bpm" unless block
         raise ArgumentError, "with_bpm's BPM should be a positive value. You tried to use: #{bpm}" unless bpm > 0
-        current_mul = __get_spider_time
-        sleep_mul = 60.0 / bpm
-        __change_spider_sleep_mul!(sleep_mul)
+        current_bpm = __get_spider_bpm
+        __change_spider_bpm!(bpm)
         res = block.call
-        __change_spider_sleep_mul!(current_mul)
+        __change_spider_bpm!(curent_bpm)
         res
       end
       doc name:           :with_bpm,
@@ -3685,11 +3674,11 @@ def with_bpm(bpm, &block)
       def with_bpm_mul(mul, &block)
         raise ArgumentError, "with_bpm_mul must be called with a do/end block. Perhaps you meant use_bpm_mul" unless block
         raise ArgumentError, "with_bpm_mul's mul should be a positive value. You tried to use: #{mul}" unless mul > 0
-        current_mul = __get_spider_sleep_mul
-        new_mul = current_mul.to_f / mul
-        __change_spider_sleep_mul!(new_mul)
+        current_bpm = __get_spider_bpm
+        new_bpm = current_bpm * mul.to_f
+        __change_spider_bpm!(new_bpm)
         res = block.call
-        __change_spider_sleep_mul!(current_mul)
+        __change_spider_bpm!(current_bpm)
         res
       end
       doc name:           :with_bpm_mul,
@@ -3720,9 +3709,8 @@ def with_bpm_mul(mul, &block)
       def use_bpm_mul(mul, &block)
         raise ArgumentError, "use_bpm_mul must not be called with a block. Perhaps you meant with_bpm_mul" if block
         raise ArgumentError, "use_bpm_mul's mul should be a positive value. You tried to use: #{mul}" unless mul > 0
-        current_mul = __get_spider_sleep_mul
-        new_mul = current_mul.to_f / mul
-        __change_spider_sleep_mul!(new_mul)
+        new_bpm = __get_spider_bpm * mul.to_f
+        __change_spider_bpm!(new_bpm)
       end
       doc name:           :use_bpm_mul,
           introduced:     Version.new(2,3,0),
@@ -4145,27 +4133,16 @@ def sleep(beats)
 
         # Schedule messages
         __schedule_delayed_blocks_and_messages!
-        __change_spider_beat!(__get_spider_beat + beats)
         return if beats == 0
 
-        # Grab the current virtual time
-        last_vt = __get_spider_time
-
-        in_time_warp = __system_thread_locals.get(:sonic_pi_spider_in_time_warp)
-
-        # Now get on with syncing the rest of the sleep time...
-
-        # Calculate the amount of time to sleep (take into account current bpm setting)
-        sleep_time = beats * __get_spider_sleep_mul
-
-        # Calculate the new virtual time
-        new_vt = last_vt + sleep_time
+        __change_spider_beat_and_time_by_beat_delta!(beats)
 
         sat = current_sched_ahead_time
-        __change_spider_time!(new_vt)
-
+        new_vt = __get_spider_time
         now = Time.now
 
+        in_time_warp = __system_thread_locals.get(:sonic_pi_spider_in_time_warp)
+
         if now - (sat + 0.5) > new_vt
           raise TimingError, "Timing Exception: thread got too far behind time"
         elsif (now - sat) > new_vt
@@ -4193,9 +4170,10 @@ def sleep(beats)
           end
         else
           if in_time_warp
-            # Don't sleep if within a time shift
+            # Don't sleep if within a time warp
+            #
             # However, do make sure the vt hasn't got too far ahead of the real time
-             raise TimingError, "Timing Exception: thread got too far ahead of time" if  (new_vt - 17) > now
+            # raise TimingError, "Timing Exception: thread got too far ahead of time" if  (new_vt - 17) > now
           else
             Kernel.sleep new_vt - now
           end
@@ -4338,14 +4316,14 @@ def sync_event(*args)
         se = @event_history.sync(t, p, i, d, b, m, cue_id, arg_matcher)
 
         __system_thread_locals.set(:sonic_pi_spider_synced, true)
-        __change_spider_beat!(se.beat)
 
-        __change_spider_time!(se.time)
+        ## only need to use se for beat and time if not in :link or :metro bpm
+        __change_spider_time_and_beat!(se.time, se.beat)
         __system_thread_locals.set_local :sonic_pi_local_last_sync, se
 
         if bpm_sync
           bpm = se.bpm <= 0 ? 60 : se.bpm
-          __change_spider_sleep_mul!(60.0 / bpm)
+          use_bpm bpm
         end
 
         run_info = ""
diff --git a/app/server/ruby/lib/sonicpi/lang/sound.rb b/app/server/ruby/lib/sonicpi/lang/sound.rb
@@ -138,7 +138,6 @@ def self.included(base)
             end
 
             @life_hooks.on_exit do |job_id, payload|
-              __system_thread_locals.set(:sonic_pi_spider_start_time, payload[:start_t])
               __system_thread_locals.set_local(:sonic_pi_local_thread_group, "job_remover-#{job_id}".freeze)
               Thread.current.priority = -10
               shutdown_job_mixer(job_id)
diff --git a/app/server/ruby/lib/sonicpi/runtime.rb b/app/server/ruby/lib/sonicpi/runtime.rb
@@ -89,6 +89,68 @@ def load_snippets(path=snippets_path, quiet=false)
       end
     end
 
+    ### Start - Spider Time Management functions
+    ###
+    def __change_spider_time_and_beat!(new_time, new_beat)
+      __system_thread_locals.set :sonic_pi_spider_time, new_time.freeze
+      __system_thread_locals.set(:sonic_pi_spider_beat, new_beat)
+    end
+
+    def __reset_spider_time_and_beat!
+      t = Time.now.freeze
+      __change_spider_time_and_beat!(t, 0)
+      __system_thread_locals.set :sonic_pi_spider_start_time, t
+    end
+
+    def __change_spider_bpm!(new_bpm)
+      __system_thread_locals.set :sonic_pi_spider_bpm, new_bpm.to_f
+    end
+
+    def __reset_spider_bpm!
+      __change_spider_bpm!(60.0)
+    end
+
+    def __change_spider_beat_and_time_by_beat_delta!(beat_delta)
+      sleep_time = beat_delta * __get_spider_sleep_mul
+      new_time   = __get_spider_time + sleep_time
+      new_beat = __get_spider_beat + beat_delta
+      __change_spider_time_and_beat!(new_time, new_beat)
+    end
+
+    def __get_spider_time
+      __system_thread_locals.get(:sonic_pi_spider_time)
+    end
+
+    def __get_spider_schedule_time
+      __system_thread_locals.get(:sonic_pi_spider_time) + current_sched_ahead_time
+    end
+
+    def __get_spider_sleep_mul
+      60.0 / __system_thread_locals.get(:sonic_pi_spider_bpm)
+    end
+
+    def __get_spider_bpm
+      __system_thread_locals.get(:sonic_pi_spider_bpm)
+    end
+
+    def __get_spider_beat
+      __system_thread_locals.get(:sonic_pi_spider_beat)
+    end
+
+    def __get_spider_start_time
+      __system_thread_locals.get :sonic_pi_spider_start_time
+    end
+
+    def __with_preserved_spider_time_and_beat(&blk)
+      time = __get_spider_time
+      beat = __get_spider_beat
+      blk.call
+      __change_spider_time_and_beat!(time, beat)
+    end
+    ### End - Spider Time Management functions
+    ###
+
+
     def __register_internal_cue_event(address, args)
       p = 0
       d = 0
@@ -735,8 +797,8 @@ def __set_default_system_thread_locals!
     end
 
     def __set_default_user_thread_locals!
+      __reset_spider_bpm!
       __thread_locals.set :sonic_pi_spider_arg_bpm_scaling, true
-      __change_spider_sleep_mul!(1.0)
       __thread_locals.set :sonic_pi_spider_new_thread_random_gen_idx, 0
       __system_thread_locals.set(:sonic_pi_spider_thread_priority, 0)
     end
@@ -774,9 +836,7 @@ def __spider_eval(code, info={})
           now = Time.now.freeze
           start_t_prom.deliver! now
           ## fix this for link
-          __change_spider_time! now
-          __system_thread_locals.set :sonic_pi_spider_start_time, now
-          __change_spider_beat! 0
+          __reset_spider_time_and_beat!
           if num_running_jobs == 1
             @global_start_time = now
             # Force a GC collection before we start making music!
@@ -888,37 +948,8 @@ def __gui_cue_log_idxs
       @gui_cue_log_idxs
     end
 
-    def __change_spider_time!(new_vt)
-      __system_thread_locals.set :sonic_pi_spider_time, new_vt.freeze
-    end
-
-    def __change_spider_sleep_mul!(new_sleep_mul)
-      __system_thread_locals.set(:sonic_pi_spider_sleep_mul, new_sleep_mul)
-    end
-
-    def __change_spider_beat!(new_beat)
-      __system_thread_locals.set(:sonic_pi_spider_beat, new_beat)
-    end
-
-    def __get_spider_time
-      __system_thread_locals.get(:sonic_pi_spider_time)
-    end
-
-    def __get_spider_schedule_time
-      __system_thread_locals.get(:sonic_pi_spider_time) + current_sched_ahead_time
-    end
-
-    def __get_spider_sleep_mul
-      __system_thread_locals.get(:sonic_pi_spider_sleep_mul)
-    end
 
-    def __get_spider_bpm
-      60.0 / __get_spider_sleep_mul
-    end
 
-    def __get_spider_beat
-      __system_thread_locals.get(:sonic_pi_spider_beat)
-    end
 
 
 
diff --git a/app/server/ruby/lib/sonicpi/scsynthexternal.rb b/app/server/ruby/lib/sonicpi/scsynthexternal.rb
@@ -52,10 +52,9 @@ def send(*all_args)
     def send_at(ts, *all_args)
       address, *args = *all_args
       if osc_debug_mode
-
-        if (a = __get_spider_time) && (b = __system_thread_locals.get(:sonic_pi_spider_start_time))
+        if (a = __get_spider_time) && (b = __get_spider_start_time)
           vt = a - b
-        elsif st = __system_thread_locals.get(:sonic_pi_spider_start_time)
+        elsif st = __get_spider_start_time
           vt = ts - st
         else
           vt = -1
diff --git a/app/server/ruby/test/setup_test.rb b/app/server/ruby/test/setup_test.rb
@@ -100,9 +100,8 @@ def run(&blk)
         __system_thread_locals.set :sonic_pi_spider_silent, silent
         __system_thread_locals.set :sonic_pi_spider_job_info, info
 
-        __change_spider_time! now
-        __change_spider_beat! 0
-        __system_thread_locals.set :sonic_pi_spider_start_time, now
+        __reset_spider_time_and_beat!
+
         __system_thread_locals.set_local :sonic_pi_local_spider_delayed_messages, []
 
         __set_default_system_thread_locals!
