Implement xmlrpc tuner server.

.github/workflows/presubmit.yml

@@ -55,7 +55,7 @@ jobs:
       - run: make -j check-valgrind-helgrind
         working-directory: build
         if: ${{ matrix.os == 'ubuntu-latest' }}
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         if: failure()
         with:
           name: build-and-check

bindings/ruby/test/test_tuner.rb

@@ -170,5 +170,130 @@ def test_user_defined
     assert( t_copy.optima.collect(&:configuration).include?(t_copy.suggest) )
     File.delete('tuner.ccs')
   end
+
+  require 'open3'
+  require 'xmlrpc/client'
+  require 'base64'
+  class TunerProxy
+    attr_reader :server
+    attr_reader :id
+    attr_reader :handle_map
+    attr_reader :objective_space
+    def initialize(name: "", objective_space: nil)
+      @server = XMLRPC::Client.new2('http://localhost:8080/RPC2')
+      connected = false
+      start = Time.now
+      while !connected
+        begin
+          connected = server.call('connected')
+        rescue
+          raise if Time.now - start > 10
+        end
+      end
+      if objective_space
+        @objective_space = objective_space
+        buff = objective_space.serialize
+        str = Base64.encode64(buff.get_bytes(0, buff.size))
+        @id, result = server.call('tuner.create', name, str)
+        @handle_map = CCS.deserialize(buffer: FFI::MemoryPointer.from_string(Base64.decode64(result)))
+      else
+        @id, result = server.call('tuner.load', name)
+        @handle_map = CCS::Map.new
+        @objective_space = CCS.deserialize(buffer: FFI::MemoryPointer.from_string(Base64.decode64(result)), handle_map: @handle_map, map_handles: true)
+        map = CCS::Map.new
+        @handle_map.pairs.select { |_ , v|
+          v.is_a?(CCS::Context) || v.is_a?(CCS::TreeSpace)
+        }.each { |k, v|
+          map[CCS::Object::new(v.handle, retain: false, auto_release: false)] = k
+        }
+        buff = map.serialize
+        server.call('tuner.set_handle_map', @id, Base64.encode64(buff.get_bytes(0, buff.size)))
+      end
+    end
+
+    def ask(count = 1)
+      server.call('tuner.ask', @id, 100).collect { |c|
+        CCS.deserialize(buffer: FFI::MemoryPointer.from_string(Base64.decode64(c)), handle_map: @handle_map)
+      }
+    end
+
+    def tell(evals = nil)
+      evals_serialized = evals.collect { |e| e.serialize }.collect { |buff| Base64.encode64(buff.get_bytes(0, buff.size)) }
+      server.call('tuner.tell', @id, evals_serialized)
+      self
+    end
+
+    def history
+      server.call('tuner.history', @id).collect { |e|
+        CCS.deserialize(buffer: FFI::MemoryPointer.from_string(Base64.decode64(e)), handle_map: @handle_map)
+      }
+    end
+
+    def history_size
+      server.call('tuner.history_size', @id)
+    end
+
+    def optima
+      server.call('tuner.optima', @id).collect { |e|
+        CCS.deserialize(buffer: FFI::MemoryPointer.from_string(Base64.decode64(e)), handle_map: @handle_map)
+      }
+    end
+
+    def num_optima
+      server.call('tuner.num_optima', @id)
+    end
+
+    def suggest
+      e = server.call('tuner.suggest', @id)
+      CCS.deserialize(buffer: FFI::MemoryPointer.from_string(Base64.decode64(e)), handle_map: @handle_map)
+    end
+
+    def save
+      server.call('tuner.save', @id)
+    end
+  end
+
+  def test_server
+    begin
+      pid = nil
+      thr = Thread.new do
+        Open3.popen2e(RbConfig.ruby, File.join(File.dirname(__FILE__), 'tuner_server.rb')) { |stdin, stdout_stderr, wait_thr|
+          pid = wait_thr.pid
+          stdout_stderr.read
+        }
+      end
+      os = create_tuning_problem
+      t = TunerProxy.new(name: "my_tuner", objective_space: os)
+      func = lambda { |(x, y, z)|
+        [(x-2)**2, Math.sin(z+y)]
+      }
+      evals = t.ask(100).collect { |c|
+        CCS::Evaluation::new(objective_space: os, configuration: c, values: func[c.values])
+      }
+      t.tell evals
+      hist = t.history
+      assert_equal(100, hist.size)
+      evals = t.ask(100).collect { |c|
+        CCS::Evaluation::new(objective_space: os, configuration: c, values: func[c.values])
+      }
+      t.tell evals
+      assert_equal(200, t.history_size)
+      objs = t.optima.collect(&:objective_values).sort
+      objs.collect { |(_, v)| v }.each_cons(2) { |v1, v2| assert( (v1 <=> v2) > 0 ) }
+      assert( t.optima.collect(&:configuration).include?(t.suggest) )
+
+      t.save
+      t_copy = TunerProxy.new(name: "my_tuner")
+      hist = t_copy.history
+      assert_equal(200, hist.size)
+      assert_equal(t.num_optima, t_copy.num_optima)
+      objs = t_copy.optima.collect(&:objective_values).sort
+      objs.collect { |(_, v)| v }.each_cons(2) { |v1, v2| assert( (v1 <=> v2) > 0 ) }
+      assert( t_copy.optima.collect(&:configuration).include?(t_copy.suggest) )
+    ensure
+      Process.kill("TERM", pid)
+      thr.join
+    end
+  end
 end
 

bindings/ruby/test/tuner_server.rb

@@ -0,0 +1,211 @@
+require 'minitest/autorun'
+require_relative '../lib/cconfigspace'
+require 'xmlrpc/server'
+require 'base64'
+
+CCS.init
+
+class TunerData
+  attr_accessor :history, :optima
+  def initialize
+    @history = []
+    @optima = []
+  end
+end
+
+del = lambda { |tuner| nil }
+ask = lambda { |tuner, _, count|
+  if count
+    cs = tuner.search_space
+    [cs.samples(count), count]
+  else
+    [nil, 1]
+  end
+}
+tell = lambda { |tuner, evaluations|
+  tuner.tuner_data.history.concat(evaluations)
+  evaluations.each { |e|
+    discard = false
+    tuner.tuner_data.optima = tuner.tuner_data.optima.collect { |o|
+      unless discard
+        case e.compare(o)
+        when :CCS_COMPARISON_EQUIVALENT, :CCS_COMPARISON_WORSE
+          discard = true
+          o
+        when :CCS_COMPARISON_NOT_COMPARABLE
+          o
+        else
+          nil
+        end
+      else
+        o
+      end
+    }.compact
+    tuner.tuner_data.optima.push(e) unless discard
+  }
+}
+get_history = lambda { |tuner, _|
+  tuner.tuner_data.history
+}
+get_optima = lambda { |tuner, _|
+  tuner.tuner_data.optima
+}
+suggest = lambda { |tuner, _|
+  if tuner.tuner_data.optima.empty?
+    ask.call(tuner, 1)
+  else
+    tuner.tuner_data.optima.sample.configuration
+  end
+}
+get_vector_data = lambda { |otype, name|
+  [CCS::UserDefinedTuner.get_vector(del: del, ask: ask, tell: tell, get_optima: get_optima, get_history: get_history, suggest: suggest), TunerData.new]
+}
+
+s = XMLRPC::Server.new(8080)
+count = 0
+tuners = {}
+# Could be on disk
+tuners_store = {}
+mutex = Mutex.new
+
+TunerStruct = Struct.new(:tuner, :handle_map)
+
+s.add_handler('connected') do
+  true
+end
+
+s.add_handler('tuner.create') do |name, os_string|
+  handle_map = CCS::Map.new
+  os_string = Base64.decode64(os_string)
+  os = CCS.deserialize(buffer: FFI::MemoryPointer.from_string(os_string), handle_map: handle_map, map_handles: true)
+  t = CCS::UserDefinedTuner::new(name: name, objective_space: os, del: del, ask: ask, tell: tell, get_optima: get_optima, get_history: get_history, suggest: suggest, tuner_data: TunerData.new)
+
+  map = CCS::Map.new
+  handle_map.pairs.select { |_ , v|
+     v.is_a?(CCS::Context) || v.is_a?(CCS::TreeSpace)
+    }.each { |k, v|
+     map[CCS::Object::new(v.handle, retain: false, auto_release: false)] = k
+    }
+  buff = map.serialize
+  tstruct = TunerStruct.new(t, handle_map)
+  id = nil
+  mutex.synchronize {
+    id = count
+    count += 1
+    tuners[id] = tstruct
+  }
+  [id, Base64.encode64(buff.get_bytes(0, buff.size))]
+end
+
+s.add_handler('tuner.ask') do |id, count|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  tstruct.tuner.ask(count).collect { |c|
+    buff = c.serialize
+    Base64.encode64(buff.get_bytes(0, buff.size))
+  }
+end
+
+s.add_handler('tuner.tell') do |id, evals|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  evals.collect! { |e|
+    e = Base64.decode64(e)
+    CCS.deserialize(buffer: FFI::MemoryPointer.from_string(e), handle_map: tstruct.handle_map)
+  }
+  tstruct.tuner.tell evals
+  true
+end
+
+s.add_handler('tuner.history') do |id|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  tstruct.tuner.history.collect { |e|
+    buff = e.serialize
+    Base64.encode64(buff.get_bytes(0, buff.size))
+  }
+end
+
+s.add_handler('tuner.history_size') do |id|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  tstruct.tuner.history_size
+end
+
+s.add_handler('tuner.optima') do |id|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  tstruct.tuner.optima.collect { |e|
+    buff = e.serialize
+    Base64.encode64(buff.get_bytes(0, buff.size))
+  }
+end
+
+s.add_handler('tuner.num_optima') do |id|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  tstruct.tuner.num_optima
+end
+
+s.add_handler('tuner.suggest') do |id|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  e = tstruct.tuner.suggest
+  buff = e.serialize
+  Base64.encode64(buff.get_bytes(0, buff.size))
+end
+
+s.add_handler('tuner.save') do |id|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  buff = tstruct.tuner.serialize
+  mutex.synchronize {
+    tuners_store[tstruct.tuner.name] = buff.get_bytes(0, buff.size)
+  }
+  true
+end
+
+s.add_handler('tuner.load') do |name|
+  buff = nil
+  mutex.synchronize {
+    buff = tuners_store[name]
+  }
+  t = CCS.deserialize(buffer: buff, vector_callback: get_vector_data)
+  tstruct = TunerStruct.new(t, nil)
+  id = nil
+  mutex.synchronize {
+    id = count
+    count += 1
+    tuners[id] = tstruct
+  }
+  buff = t.objective_space.serialize
+  [id, Base64.encode64(buff.get_bytes(0, buff.size))]
+end
+
+s.add_handler('tuner.set_handle_map') do |id, map_str|
+  tstruct = nil
+  mutex.synchronize {
+    tstruct = tuners[id]
+  }
+  tstruct.handle_map = CCS.deserialize(buffer: FFI::MemoryPointer.from_string(Base64.decode64(map_str)))
+  true
+end
+
+s.serve
+