Lang - reluctantly roll back support for changing the FX context of a live loop

This unfortunately introduced too many subtle bugs. I think I either need to have another go from scratch - or more likely - the whole threading model needs *properly* re-designing and re-building :-(

Author: samaaron

CHANGELOG.md

@@ -38,75 +38,12 @@
 
 ## version 5 'Live Loop'
 
-This new release of Sonic Pi introduces a breaking change in the interaction between `live_loop`s and `with_fx` that significantly improve using them together in a live performance. There has also been a significant overhaul of the shortcuts in the GUI to allow you to change them. You can now choose between the default (called Emacs Live), Windows or Mac modes as well as customise them yourself. There's also a wonderful new function for working with tuplets designed by Dago Sondervan.
-
-Before we get to the full breakdown list of all the changes, let's take a moment to explore the breaking change with `live_loop` and `with_f`:
-
-### Live Loop Now Behaves like Live Audio
-
-Consider this code:
-
-```ruby
-with_fx :reverb do
-  live_audio :moog
-end
-```
-
-When you run this code, the audio from the sound card is played through reverb. Now, what if you're in the middle of a performance and wanted to change it to distortion? Easy, you just change the code to this and hit run again:
-
-```ruby
-with_fx :distortion do
-  live_audio :moog
-end
-```
-
-The live_audio magically moves out of the Reverb context and into the Distortion. There's no need to stop and start the code - it all happens live and is completely seemless. As an added bonus, behind the scenes the Reverb figures that the live_audio has moved on and automatically garbage collects itself freeing the resources. The crowd dances to the distorted Moog synth.
-
-Now consider this:
-
-```ruby
-with_fx :reverb do
-  live_loop :foo do
-    play 70
-    sleep 0.5
-  end
-end
-```
-
-As with the live_audio - this works as expected, the sound from the live loop is played through Reverb. However, if you changed the reverb to Distortion and hit run again, it did not change the FX over to the Distortion. The live loop wass stuck in the Reverb FX it was originally created in. Forever. This wasn't ideal and confused a lot of people.
-
-It unfortunately stayed like this for many years because it was an incredibly hard problem to fix due to the architecture of Sonic Pi's internals. It required deep changes to the thread management system, the live loop implementation, and with_fx and its auto FX garbage collection system. Each of these is tricky enough to work on independently - but the intersection of them all is a thing of nightmares.
-
-Well, now more because the work is done and this behaves like live loop. Swap the code to this, hit the run whilst it's still playing and you'll hear the `:foo` `live_loop` played through distortion:
-
-```ruby
-with_fx :distortion do
-  live_loop :foo do
-    play 70
-    sleep 0.5
-  end
-end
-```
-
-You can even change the FX to one with a control parameter and it will still just work:
-
-```ruby
-with_fx :lpf do |fx|
-  live_loop :foo do
-     control fx, cutoff: rrand(70, 120)
-     synth :square, note: :e3, release: 0.2
-     sleep 0.25
-  end
-end
-```
-
-When you're working with fast spinning `live_loop`s it's now generally better to put your FX outside the `live_loop` as it's much more efficient. You just have one FX running the whole time, rather than creating a new FX every time the loop spins round.
+This new release of Sonic Pi introduces a significant overhaul of the shortcuts in the GUI to allow you to change them. You can now choose between the default (called Emacs Live), Windows or Mac modes as well as customise them yourself. There's also a wonderful new function for working with tuplets designed by Dago Sondervan.
 
 ### GUI
 * Complete overhaul of the shortcut system.
 
 ### Improvements
-* `live_loop` now moves to new FX contexts similar to `live_audio`. You can therefore now use `with_fx` both within and outside of `live_loop` and be able to change things live in a performance.
 * Where supported, you can now indepedently specify different input and output sound cards in the `audio-settings.toml` config file. This is done with the new options `input_sound_card_name = ""` and `output_sound_card_name = ""`. Note, you still have to ensure that the sample rate is the same for input and output.
 * Incoming OSC bundles are now supported. Timestamps are ignored (if OSC scheduling is a commonly requested feature this could be added in the future). This increases compatability with software which exlusively sends OSC in budle format such as TouchDesigner.
 
@@ -118,7 +55,6 @@ When you're working with fast spinning `live_loop`s it's now generally better to
 * Two new ride cymbals `:ride_tri` and `ride_via`.
 * New hi-hat `:hat_len`.
 
-
 ### Translations
 
 * Improvements to the French, German, Korean, Polish, Portuguese, Portguguese (Brazil), Russian and Turkish, translations.

app/server/ruby/lib/sonicpi/lang/core.rb

@@ -15,7 +15,6 @@
 require_relative "../version"
 require_relative "../util"
 require_relative "../runtime"
-require_relative "../promise"
 require_relative "western_theory"
 
 ## TODO: create _* equivalents of all fns - for silent (i.e computation) versions
@@ -2297,130 +2296,22 @@ def live_loop(name=nil, *args, &block)
           raise ArgumentError, "Live loop block must only accept 0 or 1 args"
         end
 
-        start_live_loop = Promise.new
-        parent_thread = Thread.current
-        mk_live_loop = lambda do
-          in_thread(name: ll_name, delay: delay, sync: sync_sym, sync_bpm: sync_bpm_sym) do
-
-            start_live_loop.get
-            __system_thread_locals.set_local :sonic_pi_local_live_loop_auto_cue, auto_cue
-            if args_h.has_key?(:init)
-              res = args_h[:init]
-            else
-              res = 0
-            end
-            use_random_seed args_h[:seed] if args_h[:seed]
-
-            loop do
-              new_bus = nil
-              new_group = nil
-              new_parent_t = nil
-              completed_prom = nil
-              new_thread_moved_prom = nil
-              new_thread_moved_ack_prom = nil
-              __system_thread_locals.get(:sonic_pi_local_spider_thread_move_mut).synchronize do
-                new_bus, new_group, new_parent_t, completed_prom, new_thread_moved_prom, new_thread_moved_ack_prom = __system_thread_locals.get :sonic_pi_local_live_loop_move_to_bus_and_parent_t
-
-                # immediately reset for the next move
-                __system_thread_locals.set_local :sonic_pi_local_live_loop_move_to_bus_and_parent_t, nil
-              end
-              if new_bus
-                moved_prom = __system_thread_locals.get :sonic_pi_local_spider_thread_moved
-                ack_prom = __system_thread_locals.get :sonic_pi_local_spider_thread_moved_ack
-                # update the context
-                # reset tracker and send old tracker with ack
-                tracker = __current_tracker
-                __system_thread_locals.set_local(:sonic_pi_local_tracker, nil)
-                __system_thread_locals.set(:sonic_pi_mod_sound_synth_out_bus, new_bus)
-                __system_thread_locals.set(:sonic_pi_mod_sound_job_group, new_group)
-                moved_prom.deliver! tracker
-                ack_prom.get
-                __system_thread_locals.set_local :sonic_pi_local_spider_thread_moved, new_thread_moved_prom
-                __system_thread_locals.set_local :sonic_pi_local_spider_thread_moved_ack, new_thread_moved_ack_prom
-                __system_thread_locals.set_local :sonic_pi_local_live_loop_move_to_bus_and_parent_t, nil
-                new_job_id = __system_thread_locals(new_parent_t).get(:sonic_pi_spider_job_id)
-                job_subthread_move_named(Thread.current, new_job_id, ll_name)
-                __remove_thread_from_parent_subthreads!(Thread.current)
-                __move_thread_to_new_parent!(Thread.current, new_parent_t)
-                completed_prom.deliver! :moved
-              end
-              __live_loop_cue name if __system_thread_locals.get :sonic_pi_local_live_loop_auto_cue
-              res = send(ll_name, res)
-            end
+        in_thread(name: ll_name, delay: delay, sync: sync_sym, sync_bpm: sync_bpm_sym) do
+          __system_thread_locals.set_local :sonic_pi_local_live_loop_auto_cue, auto_cue
+          if args_h.has_key?(:init)
+            res = args_h[:init]
+          else
+            res = 0
+          end
+          use_random_seed args_h[:seed] if args_h[:seed]
+          loop do
+            __live_loop_cue name if __system_thread_locals.get :sonic_pi_local_live_loop_auto_cue
+            res = send(ll_name, res)
           end
         end
 
-        live_loop_thread = mk_live_loop.call
         st = sthread(ll_name)
-        if live_loop_thread.alive?
-
-          # live loop was created - this was the first time
-          # let it start normally
-          start_live_loop.deliver! :go
-        else
-          new_out_bus = current_out_bus
-          new_synth_group = current_group
-          in_thread do
-            new_thread_moved_prom = __system_thread_locals.get(:sonic_pi_local_spider_thread_moved)
-            new_thread_moved_ack_prom = __system_thread_locals.get(:sonic_pi_local_spider_thread_moved_ack)
-            move_holding_thread_prom = Promise.new
-            Thread.new do
-              __system_thread_locals.set_local :sonic_pi_local_thread_group, "ll swapper and holding thread for #{name} #{st}"
-              completed_prom = Promise.new
-
-
-              ct1 = Thread.new do
-                __system_thread_locals.set_local :sonic_pi_local_thread_group, "ll ct1 mv waiter for #{name} #{st.object_id} #{__system_thread_locals(st).get(:sonic_pi_local_thread_group)}"
-                __system_thread_locals(st).get(:sonic_pi_local_spider_thread_move_mut).synchronize do
-
-                  _b, _g, t, p = __system_thread_locals(st).get(:sonic_pi_local_live_loop_move_to_bus_and_parent_t)
-                  if p
-                    ## another live loop already registered a move, but didn't manage to swap in time - so we're going to clobber it
-                    p.deliver! :clobbered, false
-                  end
-                  __system_thread_locals(st).set_local :sonic_pi_local_live_loop_auto_cue, auto_cue if st
-                  ## register our move
-
-                  __system_thread_locals(st).set_local :sonic_pi_local_live_loop_move_to_bus_and_parent_t, [new_out_bus, new_synth_group, parent_thread, completed_prom, new_thread_moved_prom, new_thread_moved_ack_prom]
-                end
-              end
-
-              ct2 = Thread.new do
-              __system_thread_locals.set_local :sonic_pi_local_thread_group, "ll ct2 join waiter for #{name} #{st.object_id} #{__system_thread_locals(st).get(:sonic_pi_local_thread_group)}"
-                st.join
-                completed_prom.deliver! :joined, false
-              end
-
-              moved_or_clobbered = completed_prom.get
-              ct1.kill
-              ct2.kill
-
-              if moved_or_clobbered == :moved
-                st_joined_or_moved_again = Promise.new
-                mt1 = Thread.new do
-                  __system_thread_locals.set_local :sonic_pi_local_thread_group, "ll join waiter for #{name} #{st.object_id} #{__system_thread_locals(st).get(:sonic_pi_local_thread_group)}"
-                  st.join
-                  st_joined_or_moved_again.deliver! true, false
-                end
-
-                mt2 = Thread.new do
-                  __system_thread_locals.set_local :sonic_pi_local_thread_group, "ll move waiter for #{name} #{st.object_id} #{__system_thread_locals(st).get(:sonic_pi_local_thread_group)}"
-
-                  ack_p = __system_thread_locals(st).get(:sonic_pi_local_spider_thread_moved_ack)
-                  ack_p.get
-                  st_joined_or_moved_again.deliver! true, false
-                end
-                st_joined_or_moved_again.get
-                mt1.kill
-                mt2.kill
-              end
-              move_holding_thread_prom.deliver! true
-            end
-            tracker = new_thread_moved_prom.get
-            tracker.get
-            move_holding_thread_prom.get
-          end
-        end
+        __system_thread_locals(st).set_local :sonic_pi_local_live_loop_auto_cue, auto_cue if st
         st
       end
       doc name:           :live_loop,

app/server/ruby/lib/sonicpi/lang/sound.rb

@@ -1814,31 +1814,9 @@ def with_fx(fx_name, *args, &block)
               else
                 kill_delay = args_h[:kill_delay] || 1
               end
-
-              subthreads.map do |st|
-                Thread.new do
-                  __system_thread_locals.set_local :sonic_pi_local_thread_group, "wfx subthread waiter for #{fx_name} #{new_bus}"
-                  subthread_completed_or_moved = Promise.new
-                  wt1 = Thread.new do
-                    __system_thread_locals.set_local :sonic_pi_local_thread_group, "wfx join waiter for #{fx_name} #{new_bus}"
-                    st.join
-                    __system_thread_locals(st).get(:sonic_pi_local_spider_subthread_empty).get
-                    subthread_completed_or_moved.deliver! true
-                  end
-                  wt2 = Thread.new do
-                    __system_thread_locals.set_local :sonic_pi_local_thread_group, "wfx move waiter for #{fx_name} #{new_bus}"
-                    p = __system_thread_locals(st).get(:sonic_pi_local_spider_thread_moved)
-                    tracker_from_moved_thread = p.get
-                    __system_thread_locals(st).get(:sonic_pi_local_spider_thread_moved_ack).deliver! true, false
-                    tracker_from_moved_thread.get
-                    subthread_completed_or_moved.deliver! true
-                  end
-                  subthread_completed_or_moved.get
-                  wt1.kill
-                  wt2.kill
-                end
-              end.each do |jt|
-                jt.join
+              subthreads.each do |st|
+                st.join
+                __system_thread_locals(st).get(:sonic_pi_local_spider_subthread_empty).get
               end
               tracker.block_until_finished
               Kernel.sleep(kill_delay)
@@ -1847,6 +1825,8 @@ def with_fx(fx_name, *args, &block)
 
             gc_init_completed.deliver! true
           end ## end gc collection thread definition
+
+
         end
 
         ## Trigger new fx synth (placing it in the fx group) and