Implement xmlrpc tuner server.

.github/workflows/presubmit.yml

@@ -30,16 +30,16 @@ jobs:
  compiler: g++
 
  steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
  - run: sudo apt update; sudo apt install -y ${{ matrix.compiler }} ruby-dev libgsl-dev python3-dev valgrind
  if: ${{ matrix.os == 'ubuntu-latest' }}
  - run: brew install gsl automake libtool
  if: ${{ matrix.os == 'macos-latest' }}
- - uses: actions/setup-python@v4
+ - uses: actions/setup-python@v5
  with:
  python-version: '3.11'
  if: ${{ matrix.os == 'macos-latest' }}
- - run: gem install --user-install rake ffi ffi-value whittle
+ - run: gem install --user-install rake ffi ffi-value whittle xmlrpc
  - run: pip3 install --user parglare
  - run: ./autogen.sh
  - run: mkdir -p build
@@ -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
@@ -78,11 +78,11 @@ jobs:
  if: ${{ matrix.os == 'ubuntu-latest' }}
  - run: brew install gsl automake libtool
  if: ${{ matrix.os == 'macos-latest' }}
- - uses: actions/setup-python@v4
+ - uses: actions/setup-python@v5
  with:
  python-version: '3.11'
  if: ${{ matrix.os == 'macos-latest' }}
- - run: gem install --user-install rake ffi ffi-value whittle
+ - run: gem install --user-install rake ffi ffi-value whittle xmlrpc
  - run: pip3 install --user parglare
  - run: ./autogen.sh
  - run: mkdir -p build
@@ -106,11 +106,11 @@ jobs:
  if: ${{ matrix.os == 'ubuntu-latest' }}
  - run: brew install gsl automake libtool
  if: ${{ matrix.os == 'macos-latest' }}
- - uses: actions/setup-python@v4
+ - uses: actions/setup-python@v5
  with:
  python-version: '3.11'
  if: ${{ matrix.os == 'macos-latest' }}
- - run: gem install --user-install rake ffi ffi-value whittle
+ - run: gem install --user-install rake ffi ffi-value whittle xmlrpc
  - run: pip3 install --user parglare
  - run: ./autogen.sh
  - run: mkdir -p build

bindings/python/Makefile.am

@@ -39,6 +39,7 @@ EXTRA_DIST = \
  test/test_objective_space.py \
  test/test_configuration_space.py \
  test/test_feature_space.py \
+ test/tuner_server.py \
  setup.py
 
 if ISMACOS

bindings/python/cconfigspace/base.py

@@ -551,50 +551,50 @@ def serialize(self, format = 'binary', path = None, file_descriptor = None, call
  s = ct.c_size_t(0)
  res = ccs_object_serialize(self.handle, SerializeFormat.BINARY, SerializeOperation.SIZE, ct.byref(s), *options)
  Error.check(res)
- v = (ct.c_byte * s.value)()
+ v = ct.create_string_buffer(s.value)
  res = ccs_object_serialize(self.handle, SerializeFormat.BINARY, SerializeOperation.MEMORY, ct.sizeof(v), v, *options)
  Error.check(res)
- return v
+ return v.raw
 
  @classmethod
  def deserialize(cls, format = 'binary', handle_map = None, map_handles = False, vector_callback = None, path = None, buffer = None, file_descriptor = None, callback = None):
  if format != 'binary':
  raise Error(Result(Result.ERROR_INVALID_VALUE))
  mode_count = 0;
- if path:
+ if path is not None:
  mode_count += 1
- if buffer:
+ if buffer is not None:
  mode_count += 1
- if file_descriptor:
+ if file_descriptor is not None:
  mode_count += 1
  if not mode_count == 1:
  raise Error(Result(Result.ERROR_INVALID_VALUE))
- if map_handles and not handle_map:
+ if map_handles and handle_map is None:
  raise Error(Result(Result.ERROR_INVALID_VALUE))
  o = ccs_object(0)
  options = [DeserializeOption.END]
  if map_handles:
  options = [DeserializeOption.MAP_HANDLES] + options
- if handle_map:
+ if handle_map is not None:
  options = [DeserializeOption.HANDLE_MAP, handle_map.handle] + options
- if vector_callback:
+ if vector_callback is not None:
  vector_cb_wrapper = _get_deserialize_vector_callback_wrapper(vector_callback)
  vector_cb_wrapper_func = ccs_object_deserialize_vector_callback_type(vector_cb_wrapper)
  options = [DeserializeOption.VECTOR_CALLBACK, vector_cb_wrapper_func, ct.py_object()] + options
- if callback:
+ if callback is not None:
  cb_wrapper = _get_deserialize_data_callback_wrapper(callback)
  cb_wrapper_func = ccs_object_deserialize_data_callback_type(cb_wrapper)
  options = [DeserializeOption.DATA_CALLBACK, cb_wrapper_func, ct.py_object()] + options
- elif _default_user_data_deserializer:
+ elif _default_user_data_deserializer is not None:
  options = [DeserializeOption.DATA_CALLBACK, _default_user_data_deserializer, ct.py_object()] + options
- if buffer:
- s = ct.c_size_t(ct.sizeof(buffer))
- res = ccs_object_deserialize(ct.byref(o), SerializeFormat.BINARY, SerializeOperation.MEMORY, s, buffer, *options)
- elif path:
+ if buffer is not None:
+ s = len(buffer)
+ res = ccs_object_deserialize(ct.byref(o), SerializeFormat.BINARY, SerializeOperation.MEMORY, s, ct.create_string_buffer(buffer, s), *options)
+ elif path is not None:
  p = str.encode(path)
  pp = ct.c_char_p(p)
  res = ccs_object_deserialize(ct.byref(o), SerializeFormat.BINARY, SerializeOperation.FILE, pp, *options)
- elif file_descriptor:
+ elif file_descriptor is not None:
  fd = ct.c_int(file_descriptor)
  res = ccs_object_deserialize(ct.byref(o), SerializeFormat.BINARY, SerializeOperation.FILE_DESCRIPTOR, fd, *options)
  else:

bindings/python/cconfigspace/map.py

@@ -21,6 +21,10 @@ def __init__(self, handle = None, retain = False, auto_release = True):
  else:
  super().__init__(handle = handle, retain = retain, auto_release = auto_release)
 
+ @classmethod
+ def from_handle(cls, handle, retain = True, auto_release = True):
+ return cls(handle = handle, retain = retain, auto_release = auto_release)
+
  def __len__(self):
  v = ct.c_size_t()
  res = ccs_map_get_keys(self.handle, 0, None, ct.byref(v))
@@ -73,3 +77,12 @@ def values(self):
  res = ccs_map_get_values(self.handle, sz, v, None)
  Error.check(res)
  return [x.value for x in v]
+
+ def pairs(self):
+ sz = self.__len__()
+ if sz == 0:
+ return []
+ v = (Datum * sz)()
+ k = (Datum * sz)()
+ res = ccs_map_get_pairs(self.handle, sz, k, v, None)
+ return [(k[i].value, v[i].value) for i in range(sz)]

bindings/python/test/test_tuner.py

@@ -1,6 +1,13 @@
 import unittest
 import sys
 import os as _os
+import signal
+import threading
+import subprocess
+import datetime
+import base64
+import xmlrpc.client
+import ctypes as ct
 from random import choice
 sys.path.insert(1, '.')
 sys.path.insert(1, '..')
@@ -167,6 +174,104 @@ def get_vector_data(otype, name):
  self.assertTrue(t_copy.suggest() in [x.configuration for x in optims_2])
  _os.remove('tuner.ccs')
 
+ class ServerThread(threading.Thread):
+ def __init__(self):
+ self.p = None
+ threading.Thread.__init__(self)
+
+ def run(self):
+ subprocess.run(['python3', _os.path.join(_os.path.abspath(_os.path.dirname(__file__)), 'tuner_server.py')], stdout = subprocess.DEVNULL, stderr = subprocess.DEVNULL)
+
+ class TunerProxy:
+ def __init__(self, name = "", objective_space = None):
+ self.server = xmlrpc.client.ServerProxy("http://localhost:8000/")
+ connected = False
+ start = datetime.datetime.now()
+ while not connected:
+ try:
+ connected = self.server.connected()
+ except Exception as err:
+ if datetime.datetime.now() - start > datetime.timedelta(seconds = 10):
+ raise
+ if objective_space is not None:
+ self.objective_space = objective_space
+ buff = objective_space.serialize()
+ self.id, result = self.server.create(name, buff)
+ self.handle_map = ccs.deserialize(buffer = result.data)
+ else:
+ self.id, result = self.server.load(name)
+ self.handle_map = ccs.Map()
+ self.objective_space = ccs.deserialize(buffer = result.data, handle_map = self.handle_map, map_handles = True)
+ rev_map = ccs.Map()
+ for (k, v) in self.handle_map.pairs():
+ if isinstance(v, ccs.Context) or isinstance(v, ccs.TreeSpace):
+ rev_map[ccs.Object(v.handle, retain = False, auto_release = False)] = k
+ self.server.set_handle_map(self.id, rev_map.serialize())
+
+ def ask(self, count = 1):
+ return [ccs.deserialize(buffer = conf_str.data, handle_map = self.handle_map) for conf_str in self.server.ask(self.id, count)]
+
+ def tell(self, evals = []):
+ self.server.tell(self.id, [e.serialize() for e in evals])
+ return self
+
+ def history(self):
+ return [ccs.deserialize(buffer = eval_str.data, handle_map = self.handle_map) for eval_str in self.server.history(self.id)]
+
+ def history_size(self):
+ return self.server.history_size(self.id)
+
+ def optima(self):
+ return [ccs.deserialize(buffer = eval_str.data, handle_map = self.handle_map) for eval_str in self.server.optima(self.id)]
+
+ def num_optima(self):
+ return self.server.num_optima(self.id)
+
+ def suggest(self):
+ return ccs.deserialize(buffer = self.server.suggest(self.id).data, handle_map = self.handle_map)
+
+ def save(self):
+ return self.server.save(self.id)
+
+ def kill(self):
+ return self.server.kill()
+
+ def test_server(self):
+ thr = self.ServerThread()
+ thr.start()
+ try:
+
+ os = self.create_tuning_problem()
+ t = self.TunerProxy(name = 'my_tuner', objective_space = os)
+ func = lambda x, y, z: [(x-2)*(x-2), sin(z+y)]
+ evals = [ccs.Evaluation(objective_space = os, configuration = c, values = func(*(c.values))) for c in t.ask(100)]
+ t.tell(evals)
+ hist = t.history()
+ self.assertEqual(100, len(hist))
+ evals = [ccs.Evaluation(objective_space = os, configuration = c, values = func(*(c.values))) for c in t.ask(100)]
+ t.tell(evals)
+ self.assertEqual(200, t.history_size())
+ optims = t.optima()
+ objs = [x.objective_values for x in optims]
+ objs.sort(key = lambda x: x[0])
+ # assert pareto front
+ self.assertTrue(all(objs[i][1] >= objs[i+1][1] for i in range(len(objs)-1)))
+ self.assertTrue(t.suggest() in [x.configuration for x in optims])
+
+ t.save()
+ t_copy = self.TunerProxy(name = "my_tuner")
+ hist = t_copy.history()
+ self.assertEqual(200, len(hist))
+ optims_2 = t_copy.optima()
+ self.assertEqual(len(optims), len(optims_2))
+ objs = [x.objective_values for x in optims_2]
+ objs.sort(key = lambda x: x[0])
+ self.assertTrue(all(objs[i][1] >= objs[i+1][1] for i in range(len(objs)-1)))
+ self.assertTrue(t_copy.suggest() in [x.configuration for x in optims_2])
+
+ finally:
+ xmlrpc.client.ServerProxy("http://localhost:8000/").kill()
+ thr.join()
 
 if __name__ == '__main__':
  unittest.main()