From b01810a42af446667790bc963753a6e80da7b202 Mon Sep 17 00:00:00 2001 From: Brice Videau Date: Wed, 28 Jun 2023 17:12:49 -0500 Subject: [PATCH] Context parameters are now immutable. Contexts can now be thread safe. --- .../cconfigspace/configuration_space.py | 30 +- .../python/cconfigspace/features_space.py | 10 +- .../python/cconfigspace/objective_space.py | 12 +- .../python/test/test_configuration_space.py | 27 +- bindings/python/test/test_evaluation.py | 12 +- bindings/python/test/test_features_space.py | 9 +- bindings/python/test/test_features_tuner.py | 9 +- bindings/python/test/test_objective_space.py | 9 +- bindings/python/test/test_tree_evaluation.py | 6 +- bindings/python/test/test_tree_tuner.py | 3 +- bindings/python/test/test_tuner.py | 6 +- .../lib/cconfigspace/configuration_space.rb | 34 +- .../ruby/lib/cconfigspace/features_space.rb | 25 +- .../ruby/lib/cconfigspace/objective_space.rb | 25 +- .../ruby/test/test_configuration_space.rb | 27 +- bindings/ruby/test/test_evaluation.rb | 12 +- bindings/ruby/test/test_features_space.rb | 9 +- bindings/ruby/test/test_features_tuner.rb | 9 +- bindings/ruby/test/test_objective_space.rb | 11 +- bindings/ruby/test/test_tree_evaluation.rb | 6 +- bindings/ruby/test/test_tree_tuner.rb | 3 +- bindings/ruby/test/test_tuner.rb | 6 +- connectors/kokkos/ccs-kokkos-connector.cpp | 28 +- include/cconfigspace/configuration_space.h | 93 +--- include/cconfigspace/features_space.h | 57 +- include/cconfigspace/objective_space.h | 60 +- samples/test_python.c | 15 +- samples/test_python.py | 6 +- samples/test_ruby.c | 15 +- samples/test_ruby.rb | 6 +- src/cconfigspace.c | 6 +- src/cconfigspace_internal.h | 26 +- src/configuration_space.c | 527 ++++++++++-------- src/configuration_space_deserialize.h | 9 +- src/features_space.c | 136 +++-- src/features_space_deserialize.h | 11 +- src/objective_space.c | 198 ++++--- src/objective_space_deserialize.h | 11 +- src/parameter_string.c | 6 +- tests/test_condition.c | 17 +- tests/test_configuration_space.c | 127 ++--- tests/test_expression.c | 37 +- tests/test_features_space.c | 105 +--- tests/test_forbidden.c | 17 +- tests/test_random_features_tuner.c | 38 +- tests/test_random_tree_tuner.c | 4 +- tests/test_random_tuner.c | 30 +- tests/test_user_defined_features_tuner.c | 19 +- tests/test_user_defined_tree_tuner.c | 4 +- tests/test_user_defined_tuner.c | 15 +- 50 files changed, 816 insertions(+), 1107 deletions(-) diff --git a/bindings/python/cconfigspace/configuration_space.py b/bindings/python/cconfigspace/configuration_space.py index ff3d8e51..6cdc290f 100644 --- a/bindings/python/cconfigspace/configuration_space.py +++ b/bindings/python/cconfigspace/configuration_space.py @@ -8,11 +8,9 @@ from .rng import Rng from parglare.parser import Context as PContext -ccs_create_configuration_space = _ccs_get_function("ccs_create_configuration_space", [ct.c_char_p, ct.POINTER(ccs_configuration_space)]) +ccs_create_configuration_space = _ccs_get_function("ccs_create_configuration_space", [ct.c_char_p, ct.c_size_t, ct.POINTER(ccs_parameter), ct.POINTER(ccs_configuration_space)]) ccs_configuration_space_set_rng = _ccs_get_function("ccs_configuration_space_set_rng", [ccs_configuration_space, ccs_rng]) ccs_configuration_space_get_rng = _ccs_get_function("ccs_configuration_space_get_rng", [ccs_configuration_space, ct.POINTER(ccs_rng)]) -ccs_configuration_space_add_parameter = _ccs_get_function("ccs_configuration_space_add_parameter", [ccs_configuration_space, ccs_parameter, ccs_distribution]) -ccs_configuration_space_add_parameters = _ccs_get_function("ccs_configuration_space_add_parameters", [ccs_configuration_space, ct.c_size_t, ct.POINTER(ccs_parameter), ct.POINTER(ccs_distribution)]) ccs_configuration_space_set_distribution = _ccs_get_function("ccs_configuration_space_set_distribution", [ccs_configuration_space, ccs_distribution, ct.POINTER(ct.c_size_t)]) ccs_configuration_space_get_parameter_distribution = _ccs_get_function("ccs_configuration_space_get_parameter_distribution", [ccs_configuration_space, ct.c_size_t, ct.POINTER(ccs_distribution), ct.POINTER(ct.c_size_t)]) ccs_configuration_space_set_condition = _ccs_get_function("ccs_configuration_space_set_condition", [ccs_configuration_space, ct.c_size_t, ccs_expression]) @@ -30,10 +28,12 @@ class ConfigurationSpace(Context): def __init__(self, handle = None, retain = False, auto_release = True, - name = ""): + name = "", parameters = None): if handle is None: + count = len(parameters) + parameters = (ccs_parameter * count)(*[x.handle.value for x in parameters]) handle = ccs_configuration_space() - res = ccs_create_configuration_space(str.encode(name), ct.byref(handle)) + res = ccs_create_configuration_space(str.encode(name), count, parameters, ct.byref(handle)) Error.check(res) super().__init__(handle = handle, retain = False) else: @@ -55,26 +55,6 @@ def rng(self, r): res = ccs_configuration_space_set_rng(self.handle, r.handle) Error.check(res) - def add_parameter(self, parameter, distribution = None): - if distribution: - distribution = distribution.handle - res = ccs_configuration_space_add_parameter(self.handle, parameter.handle, distribution) - Error.check(res) - - def add_parameters(self, parameters, distributions = None): - count = len(parameters) - if count == 0: - return None - if distributions: - if count != len(distributions): - raise Error(Result(Result.ERROR_INVALID_VALUE)) - distribs = (ccs_distribution * count)(*[x.handle.value if x else x for x in distributions]) - else: - distribs = None - parameters = (ccs_parameter * count)(*[x.handle.value for x in parameters]) - res = ccs_configuration_space_add_parameters(self.handle, count, parameters, distribs) - Error.check(res) - def set_distribution(self, distribution, parameters): count = distribution.dimension if count != len(parameters): diff --git a/bindings/python/cconfigspace/features_space.py b/bindings/python/cconfigspace/features_space.py index feccf749..608cdfa7 100644 --- a/bindings/python/cconfigspace/features_space.py +++ b/bindings/python/cconfigspace/features_space.py @@ -3,18 +3,18 @@ from .context import Context from .parameter import Parameter -ccs_create_features_space = _ccs_get_function("ccs_create_features_space", [ct.c_char_p, ct.POINTER(ccs_features_space)]) -ccs_features_space_add_parameter = _ccs_get_function("ccs_features_space_add_parameter", [ccs_features_space, ccs_parameter]) -ccs_features_space_add_parameters = _ccs_get_function("ccs_features_space_add_parameters", [ccs_features_space, ct.c_size_t, ct.POINTER(ccs_parameter)]) +ccs_create_features_space = _ccs_get_function("ccs_create_features_space", [ct.c_char_p, ct.c_size_t, ct.POINTER(ccs_parameter), ct.POINTER(ccs_features_space)]) ccs_features_space_check_features = _ccs_get_function("ccs_features_space_check_features", [ccs_features_space, ccs_features, ct.POINTER(ccs_bool)]) ccs_features_space_check_features_values = _ccs_get_function("ccs_features_space_check_features_values", [ccs_features_space, ct.c_size_t, ct.POINTER(Datum), ct.POINTER(ccs_bool)]) class FeaturesSpace(Context): def __init__(self, handle = None, retain = False, auto_release = True, - name = ""): + name = "", parameters = None): if handle is None: + count = len(parameters) + parameters = (ccs_parameter * count)(*[x.handle.value for x in parameters]) handle = ccs_features_space() - res = ccs_create_features_space(str.encode(name), ct.byref(handle)) + res = ccs_create_features_space(str.encode(name), count, parameters, ct.byref(handle)) Error.check(res) super().__init__(handle = handle, retain = False) else: diff --git a/bindings/python/cconfigspace/objective_space.py b/bindings/python/cconfigspace/objective_space.py index 048aed51..ed73b480 100644 --- a/bindings/python/cconfigspace/objective_space.py +++ b/bindings/python/cconfigspace/objective_space.py @@ -13,9 +13,7 @@ class ObjectiveType(CEnumeration): ('MINIMIZE', 0), 'MAXIMIZE' ] -ccs_create_objective_space = _ccs_get_function("ccs_create_objective_space", [ct.c_char_p, ct.POINTER(ccs_objective_space)]) -ccs_objective_space_add_parameter = _ccs_get_function("ccs_objective_space_add_parameter", [ccs_objective_space, ccs_parameter]) -ccs_objective_space_add_parameters = _ccs_get_function("ccs_objective_space_add_parameters", [ccs_objective_space, ct.c_size_t, ct.POINTER(ccs_parameter)]) +ccs_create_objective_space = _ccs_get_function("ccs_create_objective_space", [ct.c_char_p, ct.c_size_t, ct.POINTER(ccs_parameter), ct.POINTER(ccs_objective_space)]) ccs_objective_space_add_objective = _ccs_get_function("ccs_objective_space_add_objective", [ccs_objective_space, ccs_expression, ObjectiveType]) ccs_objective_space_add_objectives = _ccs_get_function("ccs_objective_space_add_objectives", [ccs_objective_space, ct.c_size_t, ct.POINTER(ccs_expression), ct.POINTER(ObjectiveType)]) ccs_objective_space_get_objective = _ccs_get_function("ccs_objective_space_get_objective", [ccs_objective_space, ct.c_size_t, ct.POINTER(ccs_expression), ct.POINTER(ObjectiveType)]) @@ -24,10 +22,14 @@ class ObjectiveType(CEnumeration): class ObjectiveSpace(Context): def __init__(self, handle = None, retain = False, auto_release = True, - name = ""): + name = "", parameters = None): if handle is None: + count = len(parameters) + if count == 0: + raise Error(Result(Result.ERROR_INVALID_VALUE)) + parameters = (ccs_parameter * count)(*[x.handle.value for x in parameters]) handle = ccs_objective_space() - res = ccs_create_objective_space(str.encode(name), ct.byref(handle)) + res = ccs_create_objective_space(str.encode(name), count, parameters, ct.byref(handle)) Error.check(res) super().__init__(handle = handle, retain = False) else: diff --git a/bindings/python/test/test_configuration_space.py b/bindings/python/test/test_configuration_space.py index d94630cf..f46a8650 100644 --- a/bindings/python/test/test_configuration_space.py +++ b/bindings/python/test/test_configuration_space.py @@ -8,19 +8,16 @@ class TestConfigurationSpace(unittest.TestCase): def test_create(self): - cs = ccs.ConfigurationSpace(name = "space") - self.assertEqual( ccs.ObjectType.CONFIGURATION_SPACE, cs.object_type ) - self.assertEqual( "space", cs.name ) - self.assertIsInstance( cs.rng, ccs.Rng ) - self.assertEqual( 0, cs.num_parameters ) - self.assertEqual( [], cs.conditions ) - self.assertEqual( [], cs.forbidden_clauses ) h1 = ccs.NumericalParameter.Float() h2 = ccs.NumericalParameter.Float() h3 = ccs.NumericalParameter.Float() - cs.add_parameter(h1) - cs.add_parameters([h2, h3]) + cs = ccs.ConfigurationSpace(name = "space", parameters = [h1, h2, h3]) + self.assertEqual( ccs.ObjectType.CONFIGURATION_SPACE, cs.object_type ) + self.assertEqual( "space", cs.name ) + self.assertIsInstance( cs.rng, ccs.Rng ) self.assertEqual( 3, cs.num_parameters ) + self.assertEqual( [None, None, None], cs.conditions ) + self.assertEqual( [], cs.forbidden_clauses ) self.assertEqual( h1, cs.parameter(0) ) self.assertEqual( h2, cs.parameter(1) ) self.assertEqual( h3, cs.parameter(2) ) @@ -35,11 +32,10 @@ def test_create(self): self.assertTrue( cs.check(c) ) def test_set_distribution(self): - cs = ccs.ConfigurationSpace(name = "space") h1 = ccs.NumericalParameter.Float() h2 = ccs.NumericalParameter.Float() h3 = ccs.NumericalParameter.Float() - cs.add_parameters([h1, h2, h3]) + cs = ccs.ConfigurationSpace(name = "space", parameters = [h1, h2, h3]) distributions = [ ccs.UniformDistribution.Float(lower = 0.1, upper = 0.3), ccs.UniformDistribution.Float(lower = 0.2, upper = 0.6) ] d = ccs.MultivariateDistribution(distributions = distributions) @@ -63,8 +59,7 @@ def test_conditions(self): h1 = ccs.NumericalParameter.Float(lower = -1.0, upper = 1.0, default = 0.0) h2 = ccs.NumericalParameter.Float(lower = -1.0, upper = 1.0) h3 = ccs.NumericalParameter.Float(lower = -1.0, upper = 1.0) - cs = ccs.ConfigurationSpace(name = "space") - cs.add_parameters([h1, h2, h3]) + cs = ccs.ConfigurationSpace(name = "space", parameters = [h1, h2, h3]) e1 = ccs.Expression.Less(left = h2, right = 0.0) cs.set_condition(h3, e1) e2 = ccs.Expression.Less(left = h3, right = 0.0) @@ -142,8 +137,7 @@ def test_omp(self): name = 'p9', values = ['1', '8', '16']) - cs = ccs.ConfigurationSpace(name = "omp") - cs.add_parameters([p1, p2, p3, p4, p5, p6, p7, p8, p9]) + cs = ccs.ConfigurationSpace(name = "omp", parameters = [p1, p2, p3, p4, p5, p6, p7, p8, p9]) cond0 = ccs.Expression.Equal(left = p1, right = '#pragma omp #P2') cond1 = ccs.Expression.Equal(left = p1, right = '#pragma omp target teams distribute #P2') @@ -239,8 +233,7 @@ def test_omp_parse(self): name = 'p9', values = ['1', '8', '16']) - cs = ccs.ConfigurationSpace(name = "omp") - cs.add_parameters([p1, p2, p3, p4, p5, p6, p7, p8, p9]) + cs = ccs.ConfigurationSpace(name = "omp", parameters = [p1, p2, p3, p4, p5, p6, p7, p8, p9]) cs.set_condition(p2, "p1 # ['#pragma omp #P2', '#pragma omp target teams distribute #P2']") cs.set_condition(p4, "p1 == '#pragma omp target teams distribute #P4'") diff --git a/bindings/python/test/test_evaluation.py b/bindings/python/test/test_evaluation.py index 42e657b1..00ebf0fb 100644 --- a/bindings/python/test/test_evaluation.py +++ b/bindings/python/test/test_evaluation.py @@ -7,15 +7,13 @@ class TestEvaluation(unittest.TestCase): def test_create(self): - cs = ccs.ConfigurationSpace(name = "cspace") h1 = ccs.NumericalParameter.Float() h2 = ccs.NumericalParameter.Float() h3 = ccs.NumericalParameter.Float() - cs.add_parameters([h1, h2, h3]) - os = ccs.ObjectiveSpace(name = "ospace") + cs = ccs.ConfigurationSpace(name = "cspace", parameters = [h1, h2, h3]) v1 = ccs.NumericalParameter.Float() v2 = ccs.NumericalParameter.Float() - os.add_parameters([v1, v2]) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1, v2]) e1 = ccs.Expression.Variable(parameter = v1) e2 = ccs.Expression.Variable(parameter = v2) os.add_objectives( { e1: ccs.ObjectiveType.MAXIMIZE, e2: ccs.ObjectiveType.MINIMIZE } ) @@ -40,15 +38,13 @@ def test_create(self): self.assertEqual( ccs.Comparison.NOT_COMPARABLE, ev4.compare(ev1) ) def test_serialize(self): - cs = ccs.ConfigurationSpace(name = "cspace") h1 = ccs.NumericalParameter.Float() h2 = ccs.NumericalParameter.Float() h3 = ccs.NumericalParameter.Float() - cs.add_parameters([h1, h2, h3]) - os = ccs.ObjectiveSpace(name = "ospace") + cs = ccs.ConfigurationSpace(name = "cspace", parameters = [h1, h2, h3]) v1 = ccs.NumericalParameter.Float() v2 = ccs.NumericalParameter.Float() - os.add_parameters([v1, v2]) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1, v2]) e1 = ccs.Expression.Variable(parameter = v1) e2 = ccs.Expression.Variable(parameter = v2) os.add_objectives( { e1: ccs.ObjectiveType.MAXIMIZE, e2: ccs.ObjectiveType.MINIMIZE } ) diff --git a/bindings/python/test/test_features_space.py b/bindings/python/test/test_features_space.py index 528c5748..7559db96 100644 --- a/bindings/python/test/test_features_space.py +++ b/bindings/python/test/test_features_space.py @@ -8,15 +8,12 @@ class TestFeaturesSpace(unittest.TestCase): def test_create(self): - cs = ccs.FeaturesSpace(name = "space") - self.assertEqual( ccs.ObjectType.FEATURES_SPACE, cs.object_type ) - self.assertEqual( "space", cs.name ) - self.assertEqual( 0, cs.num_parameters ) h1 = ccs.NumericalParameter.Float(lower = 0.0, upper = 1.0) h2 = ccs.NumericalParameter.Float(lower = 0.0, upper = 1.0) h3 = ccs.NumericalParameter.Float(lower = 0.0, upper = 1.0) - cs.add_parameter(h1) - cs.add_parameters([h2, h3]) + cs = ccs.FeaturesSpace(name = "space", parameters = [h1, h2, h3]) + self.assertEqual( ccs.ObjectType.FEATURES_SPACE, cs.object_type ) + self.assertEqual( "space", cs.name ) self.assertEqual( 3, cs.num_parameters ) self.assertEqual( h1, cs.parameter(0) ) self.assertEqual( h2, cs.parameter(1) ) diff --git a/bindings/python/test/test_features_tuner.py b/bindings/python/test/test_features_tuner.py index f07ef5d8..01bb40f4 100644 --- a/bindings/python/test/test_features_tuner.py +++ b/bindings/python/test/test_features_tuner.py @@ -8,21 +8,18 @@ class TestFeaturesTuner(unittest.TestCase): def create_tuning_problem(self): - cs = ccs.ConfigurationSpace(name = "cspace") h1 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) h2 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) h3 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) - cs.add_parameters([h1, h2, h3]) - os = ccs.ObjectiveSpace(name = "ospace") + cs = ccs.ConfigurationSpace(name = "cspace", parameters = [h1, h2, h3]) v1 = ccs.NumericalParameter.Float(lower = float('-inf'), upper = float('inf')) v2 = ccs.NumericalParameter.Float(lower = float('-inf'), upper = float('inf')) - os.add_parameters([v1, v2]) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1, v2]) e1 = ccs.Expression.Variable(parameter = v1) e2 = ccs.Expression.Variable(parameter = v2) os.add_objectives( [e1, e2] ) - fs = ccs.FeaturesSpace(name = "fspace") f1 = ccs.CategoricalParameter(values = [True, False]) - fs.add_parameter(f1) + fs = ccs.FeaturesSpace(name = "fspace", parameters = [f1]) return (cs, fs, os) def test_create_random(self): diff --git a/bindings/python/test/test_objective_space.py b/bindings/python/test/test_objective_space.py index 55109eb7..a3c33f40 100644 --- a/bindings/python/test/test_objective_space.py +++ b/bindings/python/test/test_objective_space.py @@ -7,16 +7,13 @@ class TestObjectiveSpace(unittest.TestCase): def test_create(self): - os = ccs.ObjectiveSpace(name = "space") - self.assertEqual( "space", os.name ) - self.assertEqual( 0, os.num_parameters ) - self.assertEqual( [], os.objectives ) h1 = ccs.NumericalParameter.Float() h2 = ccs.NumericalParameter.Float() h3 = ccs.NumericalParameter.Float() - os.add_parameter(h1) - os.add_parameters([h2, h3]) + os = ccs.ObjectiveSpace(name = "space", parameters = [h1, h2, h3]) + self.assertEqual( "space", os.name ) self.assertEqual( 3, os.num_parameters ) + self.assertEqual( [], os.objectives ) self.assertEqual( h1, os.parameter(0) ) self.assertEqual( h2, os.parameter(1) ) self.assertEqual( h3, os.parameter(2) ) diff --git a/bindings/python/test/test_tree_evaluation.py b/bindings/python/test/test_tree_evaluation.py index 76072f96..8a8335a1 100644 --- a/bindings/python/test/test_tree_evaluation.py +++ b/bindings/python/test/test_tree_evaluation.py @@ -18,10 +18,9 @@ class TestTreeEvaluation(unittest.TestCase): def test_create(self): tree = generate_tree(4, 0) ts = ccs.StaticTreeSpace(name = 'space', tree = tree) - os = ccs.ObjectiveSpace(name = "ospace") v1 = ccs.NumericalParameter.Float() v2 = ccs.NumericalParameter.Float() - os.add_parameters([v1, v2]) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1, v2]) e1 = ccs.Expression.Variable(parameter = v1) e2 = ccs.Expression.Variable(parameter = v2) os.add_objectives( { e1: ccs.ObjectiveType.MAXIMIZE, e2: ccs.ObjectiveType.MINIMIZE } ) @@ -48,10 +47,9 @@ def test_create(self): def test_serialize(self): tree = generate_tree(4, 0) ts = ccs.StaticTreeSpace(name = 'space', tree = tree) - os = ccs.ObjectiveSpace(name = "ospace") v1 = ccs.NumericalParameter.Float() v2 = ccs.NumericalParameter.Float() - os.add_parameters([v1, v2]) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1, v2]) e1 = ccs.Expression.Variable(parameter = v1) e2 = ccs.Expression.Variable(parameter = v2) os.add_objectives( { e1: ccs.ObjectiveType.MAXIMIZE, e2: ccs.ObjectiveType.MINIMIZE } ) diff --git a/bindings/python/test/test_tree_tuner.py b/bindings/python/test/test_tree_tuner.py index fdfcae17..0ab62a43 100644 --- a/bindings/python/test/test_tree_tuner.py +++ b/bindings/python/test/test_tree_tuner.py @@ -25,9 +25,8 @@ class TestTreeTuner(unittest.TestCase): def create_tuning_problem(self): tree = generate_tree(5, 0) ts = ccs.StaticTreeSpace(name = 'space', tree = tree) - os = ccs.ObjectiveSpace(name = "ospace") v1 = ccs.NumericalParameter.Float(lower = float('-inf'), upper = float('inf')) - os.add_parameter(v1) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1]) e1 = ccs.Expression.Variable(parameter = v1) os.add_objectives( {e1: ccs.ObjectiveType.MAXIMIZE} ) return (ts, os) diff --git a/bindings/python/test/test_tuner.py b/bindings/python/test/test_tuner.py index b7783ae0..20838a15 100644 --- a/bindings/python/test/test_tuner.py +++ b/bindings/python/test/test_tuner.py @@ -9,15 +9,13 @@ class TestTuner(unittest.TestCase): def create_tuning_problem(self): - cs = ccs.ConfigurationSpace(name = "cspace") h1 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) h2 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) h3 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) - cs.add_parameters([h1, h2, h3]) - os = ccs.ObjectiveSpace(name = "ospace") + cs = ccs.ConfigurationSpace(name = "cspace", parameters = [h1, h2, h3]) v1 = ccs.NumericalParameter.Float(lower = float('-inf'), upper = float('inf')) v2 = ccs.NumericalParameter.Float(lower = float('-inf'), upper = float('inf')) - os.add_parameters([v1, v2]) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1, v2]) e1 = ccs.Expression.Variable(parameter = v1) e2 = ccs.Expression.Variable(parameter = v2) os.add_objectives( [e1, e2] ) diff --git a/bindings/ruby/lib/cconfigspace/configuration_space.rb b/bindings/ruby/lib/cconfigspace/configuration_space.rb index 7faab8ef..05760af2 100644 --- a/bindings/ruby/lib/cconfigspace/configuration_space.rb +++ b/bindings/ruby/lib/cconfigspace/configuration_space.rb @@ -1,9 +1,7 @@ module CCS - attach_function :ccs_create_configuration_space, [:string, :pointer], :ccs_result_t + attach_function :ccs_create_configuration_space, [:string, :size_t, :pointer, :pointer], :ccs_result_t attach_function :ccs_configuration_space_set_rng, [:ccs_configuration_space_t, :ccs_rng_t], :ccs_result_t attach_function :ccs_configuration_space_get_rng, [:ccs_configuration_space_t, :pointer], :ccs_result_t - attach_function :ccs_configuration_space_add_parameter, [:ccs_configuration_space_t, :ccs_parameter_t, :ccs_distribution_t], :ccs_result_t - attach_function :ccs_configuration_space_add_parameters, [:ccs_configuration_space_t, :size_t, :pointer, :pointer], :ccs_result_t attach_function :ccs_configuration_space_set_distribution, [:ccs_configuration_space_t, :ccs_distribution_t, :pointer], :ccs_result_t attach_function :ccs_configuration_space_get_parameter_distribution, [:ccs_configuration_space_t, :size_t, :pointer, :pointer], :ccs_result_t attach_function :ccs_configuration_space_set_condition, [:ccs_configuration_space_t, :size_t, :ccs_expression_t], :ccs_result_t @@ -22,12 +20,15 @@ module CCS class ConfigurationSpace < Context def initialize(handle = nil, retain: false, auto_release: true, - name: "") + name: "", parameters: nil) if handle super(handle, retain: retain, auto_release: auto_release) else + count = parameters.size + p_parameters = MemoryPointer::new(:ccs_parameter_t, count) + p_parameters.write_array_of_pointer(parameters.collect(&:handle)) ptr = MemoryPointer::new(:ccs_configuration_space_t) - CCS.error_check CCS.ccs_create_configuration_space(name, ptr) + CCS.error_check CCS.ccs_create_configuration_space(name, count, p_parameters, ptr) super(ptr.read_ccs_configuration_space_t, retain:false) end end @@ -47,12 +48,7 @@ def rng=(r) r end - def add_parameter(parameter, distribution: nil) - CCS.error_check CCS.ccs_configuration_space_add_parameter(@handle, parameter, distribution) - self - end - - def set_distribution(distribution, parameters ) + def set_distribution(distribution, parameters) count = distribution.dimension raise CCSError, :CCS_RESULT_ERROR_INVALID_VALUE if count != parameters.size parameters = parameters.collect { |h| @@ -84,22 +80,6 @@ def get_parameter_distribution(parameter) [CCS::Distribution.from_handle(p_distribution.read_ccs_distribution_t), p_indx.read_size_t] end - def add_parameters(parameters, distributions: nil) - count = parameters.size - return self if count == 0 - if distributions - raise CCSError, :CCS_RESULT_ERROR_INVALID_VALUE if count != distributions.size - p_dists = MemoryPointer::new(:ccs_distribution_t, count) - p_dists.write_array_of_pointer(distributions.collect(&:handle)) - else - p_dists = nil - end - p_parameters = MemoryPointer::new(:ccs_parameter_t, count) - p_parameters.write_array_of_pointer(parameters.collect(&:handle)) - CCS.error_check CCS.ccs_configuration_space_add_parameters(@handle, count, p_parameters, p_dists) - self - end - def set_condition(parameter, expression) if expression.kind_of? String expression = ExpressionParser::new(self).parse(expression) diff --git a/bindings/ruby/lib/cconfigspace/features_space.rb b/bindings/ruby/lib/cconfigspace/features_space.rb index ab6da0ce..c5bd43b9 100644 --- a/bindings/ruby/lib/cconfigspace/features_space.rb +++ b/bindings/ruby/lib/cconfigspace/features_space.rb @@ -1,18 +1,19 @@ module CCS - attach_function :ccs_create_features_space, [:string, :pointer], :ccs_result_t - attach_function :ccs_features_space_add_parameter, [:ccs_features_space_t, :ccs_parameter_t], :ccs_result_t - attach_function :ccs_features_space_add_parameters, [:ccs_features_space_t, :size_t, :pointer], :ccs_result_t + attach_function :ccs_create_features_space, [:string, :size_t, :pointer, :pointer], :ccs_result_t attach_function :ccs_features_space_check_features, [:ccs_features_space_t, :ccs_features_t, :pointer], :ccs_result_t attach_function :ccs_features_space_check_features_values, [:ccs_features_space_t, :size_t, :pointer, :pointer], :ccs_result_t class FeaturesSpace < Context def initialize(handle = nil, retain: false, auto_release: true, - name: "") + name: "", parameters: nil) if handle super(handle, retain: retain, auto_release: auto_release) else + count = parameters.size + p_parameters = MemoryPointer::new(:ccs_parameter_t, count) + p_parameters.write_array_of_pointer(parameters.collect(&:handle)) ptr = MemoryPointer::new(:ccs_features_space_t) - CCS.error_check CCS.ccs_create_features_space(name, ptr) + CCS.error_check CCS.ccs_create_features_space(name, count, p_parameters, ptr) super(ptr.read_ccs_features_space_t, retain: false) end end @@ -21,20 +22,6 @@ def self.from_handle(handle, retain: true, auto_release: true) self::new(handle, retain: retain, auto_release: auto_release) end - def add_parameter(parameter) - CCS.error_check CCS.ccs_features_space_add_parameter(@handle, parameter) - self - end - - def add_parameters(parameters) - count = parameters.size - return self if count == 0 - p_parameters = MemoryPointer::new(:ccs_parameter_t, count) - p_parameters.write_array_of_pointer(parameters.collect(&:handle)) - CCS.error_check CCS.ccs_features_space_add_parameters(@handle, count, p_parameters) - self - end - def check(features) ptr = MemoryPointer::new(:ccs_bool_t) CCS.error_check CCS.ccs_features_space_check_features(@handle, features, ptr) diff --git a/bindings/ruby/lib/cconfigspace/objective_space.rb b/bindings/ruby/lib/cconfigspace/objective_space.rb index 6c173ce6..4cadab42 100644 --- a/bindings/ruby/lib/cconfigspace/objective_space.rb +++ b/bindings/ruby/lib/cconfigspace/objective_space.rb @@ -18,9 +18,7 @@ def read_array_of_ccs_objective_type_t(count) end end - attach_function :ccs_create_objective_space, [:string, :pointer], :ccs_result_t - attach_function :ccs_objective_space_add_parameter, [:ccs_objective_space_t, :ccs_parameter_t], :ccs_result_t - attach_function :ccs_objective_space_add_parameters, [:ccs_objective_space_t, :size_t, :pointer], :ccs_result_t + attach_function :ccs_create_objective_space, [:string, :size_t, :pointer, :pointer], :ccs_result_t attach_function :ccs_objective_space_add_objective, [:ccs_objective_space_t, :ccs_expression_t, :ccs_objective_type_t], :ccs_result_t attach_function :ccs_objective_space_add_objectives, [:ccs_objective_space_t, :size_t, :pointer, :pointer], :ccs_result_t attach_function :ccs_objective_space_get_objective, [:ccs_objective_space_t, :size_t, :pointer, :pointer], :ccs_result_t @@ -30,12 +28,15 @@ def read_array_of_ccs_objective_type_t(count) class ObjectiveSpace < Context def initialize(handle = nil, retain: false, auto_release: true, - name: "") + name: "", parameters: nil) if handle super(handle, retain: retain, auto_release: auto_release) else + count = parameters.size + p_parameters = MemoryPointer::new(:ccs_parameter_t, count) + p_parameters.write_array_of_pointer(parameters.collect(&:handle)) ptr = MemoryPointer::new(:ccs_objective_space_t) - CCS.error_check CCS.ccs_create_objective_space(name, ptr) + CCS.error_check CCS.ccs_create_objective_space(name, count, p_parameters, ptr) super(ptr.read_ccs_objective_space_t, retain: false) end end @@ -44,20 +45,6 @@ def self.from_handle(handle, retain: true, auto_release: true) self::new(handle, retain: retain, auto_release: auto_release) end - def add_parameter(parameter) - CCS.error_check CCS.ccs_objective_space_add_parameter(@handle, parameter) - self - end - - def add_parameters(parameters) - count = parameters.size - return self if count == 0 - p_parameters = MemoryPointer::new(:ccs_parameter_t, count) - p_parameters.write_array_of_pointer(parameters.collect(&:handle)) - CCS.error_check CCS.ccs_objective_space_add_parameters(@handle, count, p_parameters) - self - end - def add_objective(expression, type: :CCS_OBJECTIVE_TYPE_MINIMIZE) if expression.kind_of? String expression = ExpressionParser::new(self).parse(expression) diff --git a/bindings/ruby/test/test_configuration_space.rb b/bindings/ruby/test/test_configuration_space.rb index 380f6490..e07c6e88 100644 --- a/bindings/ruby/test/test_configuration_space.rb +++ b/bindings/ruby/test/test_configuration_space.rb @@ -7,19 +7,16 @@ def setup end def test_create - cs = CCS::ConfigurationSpace::new(name: "space") - assert_equal( :CCS_OBJECT_TYPE_CONFIGURATION_SPACE, cs.object_type ) - assert_equal( "space", cs.name ) - assert( cs.rng.kind_of?(CCS::Rng) ) - assert_equal( 0, cs.num_parameters ) - assert_equal( [], cs.conditions ) - assert_equal( [], cs.forbidden_clauses ) h1 = CCS::NumericalParameter::Float.new h2 = CCS::NumericalParameter::Float.new h3 = CCS::NumericalParameter::Float.new - cs.add_parameter(h1) - cs.add_parameters([h2, h3]) + cs = CCS::ConfigurationSpace::new(name: "space", parameters: [h1, h2, h3]) + assert_equal( :CCS_OBJECT_TYPE_CONFIGURATION_SPACE, cs.object_type ) + assert_equal( "space", cs.name ) + assert( cs.rng.kind_of?(CCS::Rng) ) assert_equal( 3, cs.num_parameters ) + assert_equal( [nil, nil, nil], cs.conditions ) + assert_equal( [], cs.forbidden_clauses ) assert_equal( h1, cs.parameter(0) ) assert_equal( h2, cs.parameter(1) ) assert_equal( h3, cs.parameter(2) ) @@ -36,11 +33,10 @@ def test_create end def test_set_distribution - cs = CCS::ConfigurationSpace::new(name: "space") h1 = CCS::NumericalParameter::Float.new h2 = CCS::NumericalParameter::Float.new h3 = CCS::NumericalParameter::Float.new - cs.add_parameters([h1, h2, h3]) + cs = CCS::ConfigurationSpace::new(name: "space", parameters: [h1, h2, h3]) distributions = [ CCS::UniformDistribution::Float.new(lower: 0.1, upper: 0.3), CCS::UniformDistribution::Float.new(lower: 0.2, upper: 0.6) ] d = CCS::MultivariateDistribution::new(distributions: distributions) cs.set_distribution(d, [h1, h2]) @@ -63,8 +59,7 @@ def test_conditions h1 = CCS::NumericalParameter::Float.new(lower: -1.0, upper: 1.0, default: 0.0) h2 = CCS::NumericalParameter::Float.new(lower: -1.0, upper: 1.0) h3 = CCS::NumericalParameter::Float.new(lower: -1.0, upper: 1.0) - cs = CCS::ConfigurationSpace::new(name: "space") - cs.add_parameters([h1, h2, h3]) + cs = CCS::ConfigurationSpace::new(name: "space", parameters: [h1, h2, h3]) e1 = CCS::Expression::Less.new(left: h2, right: 0.0) cs.set_condition(h3, e1) e2 = CCS::Expression::Less.new(left: h3, right: 0.0) @@ -151,8 +146,7 @@ def test_omp name: 'p9', values: ['1', '8', '16']) - cs = CCS::ConfigurationSpace::new(name: "omp") - cs.add_parameters([p1, p2, p3, p4, p5, p6, p7, p8, p9]) + cs = CCS::ConfigurationSpace::new(name: "omp", parameters: [p1, p2, p3, p4, p5, p6, p7, p8, p9]) cond0 = CCS::Expression::Equal.new(left: p1, right: '#pragma omp #P2') cond1 = CCS::Expression::Equal.new(left: p1, right: '#pragma omp target teams distribute #P2') @@ -254,8 +248,7 @@ def test_omp_parse name: 'p9', values: ['1', '8', '16']) - cs = CCS::ConfigurationSpace::new(name: "omp") - cs.add_parameters([p1, p2, p3, p4, p5, p6, p7, p8, p9]) + cs = CCS::ConfigurationSpace::new(name: "omp", parameters: [p1, p2, p3, p4, p5, p6, p7, p8, p9]) cs.set_condition(p2, "p1 # ['#pragma omp #P2', '#pragma omp target teams distribute #P2']") cs.set_condition(p4, "p1 == '#pragma omp target teams distribute #P4'") diff --git a/bindings/ruby/test/test_evaluation.rb b/bindings/ruby/test/test_evaluation.rb index c0a0b49d..c90d8737 100644 --- a/bindings/ruby/test/test_evaluation.rb +++ b/bindings/ruby/test/test_evaluation.rb @@ -7,15 +7,13 @@ def setup end def test_create - cs = CCS::ConfigurationSpace::new(name: "cspace") h1 = CCS::NumericalParameter::Float.new h2 = CCS::NumericalParameter::Float.new h3 = CCS::NumericalParameter::Float.new - cs.add_parameters [h1, h2, h3] - os = CCS::ObjectiveSpace::new(name: "ospace") + cs = CCS::ConfigurationSpace::new(name: "cspace", parameters: [h1, h2, h3]) v1 = CCS::NumericalParameter::Float.new v2 = CCS::NumericalParameter::Float.new - os.add_parameters [v1, v2] + os = CCS::ObjectiveSpace::new(name: "ospace", parameters: [v1, v2]) e1 = CCS::Expression::Variable::new(parameter: v1) e2 = CCS::Expression::Variable::new(parameter: v2) os.add_objectives( { e1 => :CCS_OBJECTIVE_TYPE_MAXIMIZE, e2 => :CCS_OBJECTIVE_TYPE_MINIMIZE } ) @@ -46,15 +44,13 @@ def test_create end def test_serialize - cs = CCS::ConfigurationSpace::new(name: "cspace") h1 = CCS::NumericalParameter::Float.new h2 = CCS::NumericalParameter::Float.new h3 = CCS::NumericalParameter::Float.new - cs.add_parameters [h1, h2, h3] - os = CCS::ObjectiveSpace::new(name: "ospace") + cs = CCS::ConfigurationSpace::new(name: "cspace", parameters: [h1, h2, h3]) v1 = CCS::NumericalParameter::Float.new v2 = CCS::NumericalParameter::Float.new - os.add_parameters [v1, v2] + os = CCS::ObjectiveSpace::new(name: "ospace", parameters: [v1, v2]) e1 = CCS::Expression::Variable::new(parameter: v1) e2 = CCS::Expression::Variable::new(parameter: v2) os.add_objectives( { e1 => :CCS_OBJECTIVE_TYPE_MAXIMIZE, e2 => :CCS_OBJECTIVE_TYPE_MINIMIZE } ) diff --git a/bindings/ruby/test/test_features_space.rb b/bindings/ruby/test/test_features_space.rb index dfda254b..e31e4905 100644 --- a/bindings/ruby/test/test_features_space.rb +++ b/bindings/ruby/test/test_features_space.rb @@ -7,15 +7,12 @@ def setup end def test_create - cs = CCS::FeaturesSpace::new(name: "space") - assert_equal( :CCS_OBJECT_TYPE_FEATURES_SPACE, cs.object_type ) - assert_equal( "space", cs.name ) - assert_equal( 0, cs.num_parameters ) h1 = CCS::NumericalParameter::Float.new h2 = CCS::NumericalParameter::Float.new h3 = CCS::NumericalParameter::Float.new - cs.add_parameter(h1) - cs.add_parameters([h2, h3]) + cs = CCS::FeaturesSpace::new(name: "space", parameters: [h1, h2, h3]) + assert_equal( :CCS_OBJECT_TYPE_FEATURES_SPACE, cs.object_type ) + assert_equal( "space", cs.name ) assert_equal( 3, cs.num_parameters ) assert_equal( h1, cs.parameter(0) ) assert_equal( h2, cs.parameter(1) ) diff --git a/bindings/ruby/test/test_features_tuner.rb b/bindings/ruby/test/test_features_tuner.rb index b4b31be2..4273075d 100644 --- a/bindings/ruby/test/test_features_tuner.rb +++ b/bindings/ruby/test/test_features_tuner.rb @@ -7,22 +7,19 @@ def setup end def create_tuning_problem - cs = CCS::ConfigurationSpace::new(name: "cspace") h1 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) h2 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) h3 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) - cs.add_parameters [h1, h2, h3] - os = CCS::ObjectiveSpace::new(name: "ospace") + cs = CCS::ConfigurationSpace::new(name: "cspace", parameters: [h1, h2, h3]) v1 = CCS::NumericalParameter::Float.new(lower: -Float::INFINITY, upper: Float::INFINITY) v2 = CCS::NumericalParameter::Float.new(lower: -Float::INFINITY, upper: Float::INFINITY) - os.add_parameters [v1, v2] + os = CCS::ObjectiveSpace::new(name: "ospace", parameters: [v1, v2]) e1 = CCS::Expression::Variable::new(parameter: v1) e2 = CCS::Expression::Variable::new(parameter: v2) os.add_objectives( [e1, e2] ) - fs = CCS::FeaturesSpace::new(name: "fspace") f1 = CCS::CategoricalParameter::new(values: [true, false]) - fs.add_parameter f1 + fs = CCS::FeaturesSpace::new(name: "fspace", parameters: [f1]) [cs, fs, os] end diff --git a/bindings/ruby/test/test_objective_space.rb b/bindings/ruby/test/test_objective_space.rb index 0e47e09f..7aae55c1 100644 --- a/bindings/ruby/test/test_objective_space.rb +++ b/bindings/ruby/test/test_objective_space.rb @@ -7,17 +7,14 @@ def setup end def test_create - os = CCS::ObjectiveSpace::new(name: "space") - assert_equal( :CCS_OBJECT_TYPE_OBJECTIVE_SPACE, os.object_type ) - assert_equal( "space", os.name ) - assert_equal( 0, os.num_parameters ) - assert_equal( [], os.objectives ) h1 = CCS::NumericalParameter::Float.new h2 = CCS::NumericalParameter::Float.new h3 = CCS::NumericalParameter::Float.new - os.add_parameter(h1) - os.add_parameters([h2, h3]) + os = CCS::ObjectiveSpace::new(name: "space", parameters: [h1, h2, h3]) + assert_equal( :CCS_OBJECT_TYPE_OBJECTIVE_SPACE, os.object_type ) + assert_equal( "space", os.name ) assert_equal( 3, os.num_parameters ) + assert_equal( [], os.objectives ) assert_equal( h1, os.parameter(0) ) assert_equal( h2, os.parameter(1) ) assert_equal( h3, os.parameter(2) ) diff --git a/bindings/ruby/test/test_tree_evaluation.rb b/bindings/ruby/test/test_tree_evaluation.rb index fc487179..fdae0385 100644 --- a/bindings/ruby/test/test_tree_evaluation.rb +++ b/bindings/ruby/test/test_tree_evaluation.rb @@ -21,10 +21,9 @@ def generate_tree(depth, rank) def test_create tree = generate_tree(4, 0) ts = CCS::StaticTreeSpace.new(name: 'space', tree: tree) - os = CCS::ObjectiveSpace.new(name: 'ospace') v1 = CCS::NumericalParameter::Float.new v2 = CCS::NumericalParameter::Float.new - os.add_parameters([v1, v2]) + os = CCS::ObjectiveSpace.new(name: 'ospace', parameters: [v1, v2]) e1 = CCS::Expression::Variable.new(parameter: v1) e2 = CCS::Expression::Variable.new(parameter: v2) os.add_objectives( { e1 => :CCS_OBJECTIVE_TYPE_MAXIMIZE, e2 => :CCS_OBJECTIVE_TYPE_MINIMIZE } ) @@ -52,10 +51,9 @@ def test_create def test_serialize tree = generate_tree(4, 0) ts = CCS::StaticTreeSpace.new(name: 'space', tree: tree) - os = CCS::ObjectiveSpace.new(name: 'ospace') v1 = CCS::NumericalParameter::Float.new v2 = CCS::NumericalParameter::Float.new - os.add_parameters([v1, v2]) + os = CCS::ObjectiveSpace.new(name: 'ospace', parameters: [v1, v2]) e1 = CCS::Expression::Variable.new(parameter: v1) e2 = CCS::Expression::Variable.new(parameter: v2) os.add_objectives( { e1 => :CCS_OBJECTIVE_TYPE_MAXIMIZE, e2 => :CCS_OBJECTIVE_TYPE_MINIMIZE } ) diff --git a/bindings/ruby/test/test_tree_tuner.rb b/bindings/ruby/test/test_tree_tuner.rb index 5e3b5994..116c2062 100644 --- a/bindings/ruby/test/test_tree_tuner.rb +++ b/bindings/ruby/test/test_tree_tuner.rb @@ -21,9 +21,8 @@ def generate_tree(depth, rank) def create_tuning_problem tree = generate_tree(5, 0) ts = CCS::StaticTreeSpace.new(name: 'space', tree: tree) - os = CCS::ObjectiveSpace.new(name: 'ospace') v1 = CCS::NumericalParameter::Float.new(lower: -Float::INFINITY, upper: Float::INFINITY) - os.add_parameter(v1) + os = CCS::ObjectiveSpace.new(name: 'ospace', parameters: [v1]) e1 = CCS::Expression::Variable.new(parameter: v1) os.add_objectives( {e1 => :CCS_OBJECTIVE_TYPE_MAXIMIZE} ) [ts, os] diff --git a/bindings/ruby/test/test_tuner.rb b/bindings/ruby/test/test_tuner.rb index 22619857..e0ddd88f 100644 --- a/bindings/ruby/test/test_tuner.rb +++ b/bindings/ruby/test/test_tuner.rb @@ -7,15 +7,13 @@ def setup end def create_tuning_problem - cs = CCS::ConfigurationSpace::new(name: "cspace") h1 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) h2 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) h3 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) - cs.add_parameters [h1, h2, h3] - os = CCS::ObjectiveSpace::new(name: "ospace") + cs = CCS::ConfigurationSpace::new(name: "cspace", parameters: [h1, h2, h3]) v1 = CCS::NumericalParameter::Float.new(lower: -Float::INFINITY, upper: Float::INFINITY) v2 = CCS::NumericalParameter::Float.new(lower: -Float::INFINITY, upper: Float::INFINITY) - os.add_parameters [v1, v2] + os = CCS::ObjectiveSpace::new(name: "ospace", parameters: [v1, v2]) e1 = CCS::Expression::Variable::new(parameter: v1) e2 = CCS::Expression::Variable::new(parameter: v2) os.add_objectives( [e1, e2] ) diff --git a/connectors/kokkos/ccs-kokkos-connector.cpp b/connectors/kokkos/ccs-kokkos-connector.cpp index e0135a2b..d9502660 100644 --- a/connectors/kokkos/ccs-kokkos-connector.cpp +++ b/connectors/kokkos/ccs-kokkos-connector.cpp @@ -501,18 +501,21 @@ kokkosp_request_values( auto tun = tuners.find(regionId); if (tun == tuners.end()) { + ccs_parameter_t *cs_parameters; ccs_configuration_space_t cs; ccs_features_space_t fs; ccs_objective_space_t os; ccs_parameter_t htime; ccs_expression_t expression; + cs_parameters = new ccs_parameter_t[numTuningVariables]; + for (size_t i = 0; i < numTuningVariables; i++) + cs_parameters[i] = parameters[tuningValues[i].type_id]; + CCS_CHECK(ccs_create_configuration_space( ("cs (region: " + std::to_string(regionCounter) + ")").c_str(), - &cs)); - for (size_t i = 0; i < numTuningVariables; i++) - CCS_CHECK(ccs_configuration_space_add_parameter( - cs, parameters[tuningValues[i].type_id], NULL)); + numTuningVariables, cs_parameters, &cs)); + delete[] cs_parameters; #if CCS_DEBUG for (size_t i = 0; i < numTuningVariables; i++) { @@ -521,24 +524,25 @@ kokkosp_request_values( } #endif + cs_parameters = new ccs_parameter_t[numContextVariables]; + for (size_t i = 0; i < numContextVariables; i++) + cs_parameters[i] = parameters[contextValues[i].type_id]; + CCS_CHECK(ccs_create_features_space( ("fs (region: " + std::to_string(regionCounter) + ")").c_str(), - &fs)); - for (size_t i = 0; i < numContextVariables; i++) - CCS_CHECK(ccs_features_space_add_parameter( - fs, features[contextValues[i].type_id])); + numContextVariables, cs_parameters, &fs)); + delete[] cs_parameters; ccs_int_t lower = 0; ccs_int_t upper = CCS_INT_MAX; ccs_int_t step = 0; - CCS_CHECK(ccs_create_objective_space( - ("os (region: " + std::to_string(regionCounter) + ")").c_str(), - &os)); CCS_CHECK(ccs_create_numerical_parameter( "time", CCS_NUMERIC_TYPE_INT, lower, upper, step, lower, &htime)); CCS_CHECK(ccs_create_variable(htime, &expression)); - CCS_CHECK(ccs_objective_space_add_parameter(os, htime)); + CCS_CHECK(ccs_create_objective_space( + ("os (region: " + std::to_string(regionCounter) + ")").c_str(), + 1, &htime, &os)); CCS_CHECK(ccs_objective_space_add_objective( os, expression, CCS_OBJECTIVE_TYPE_MINIMIZE)); CCS_CHECK(ccs_release_object(expression)); diff --git a/include/cconfigspace/configuration_space.h b/include/cconfigspace/configuration_space.h index 5e0705ed..4e34e1bc 100644 --- a/include/cconfigspace/configuration_space.h +++ b/include/cconfigspace/configuration_space.h @@ -15,13 +15,22 @@ extern "C" { */ /** - * Create a new empty configuration space. + * Create a new configuration space. * @param[in] name pointer to a string that will be copied internally + * @param[in] num_parameters the number of provided parameters + * @param[in] parameters an array of \p num_parameters parameters + * to add to the configuration space * @param[out] configuration_space_ret a pointer to the variable that will hold * the newly created configuration space * @return #CCS_RESULT_SUCCESS on success * @return #CCS_RESULT_ERROR_INVALID_VALUE if \p name is NULL; or if \p - * configuration_space_ret is NULL + * configuration_space_ret is NULL; or if \p parameters is NULL; or if \p + * num_parameters is NULL + * @return #CCS_RESULT_ERROR_INVALID_OBJECT if a parameter is not a valid CCS + * parameter + * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if a parameter's type is + * CCS_PARAMETER_TYPE_STRING; or if a parameter appears more than once in \p + * parameters; or if two or more parameters share the same name * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if there was a lack of memory to * allocate the new configuration space * @remarks @@ -30,6 +39,8 @@ extern "C" { extern ccs_result_t ccs_create_configuration_space( const char *name, + size_t num_parameters, + ccs_parameter_t *parameters, ccs_configuration_space_t *configuration_space_ret); /** @@ -57,7 +68,7 @@ ccs_configuration_space_get_name( * @return #CCS_RESULT_ERROR_INVALID_OBJECT if \p configuration_space is not a * valid CCS configuration space; or \p rng is not a valid CCS rng * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_configuration_space_set_rng( @@ -80,70 +91,6 @@ ccs_configuration_space_get_rng( ccs_configuration_space_t configuration_space, ccs_rng_t *rng_ret); -/** - * Add a parameter to the configuration space. - * @param[in,out] configuration_space - * @param[in] parameter the parameter to add to the configuration - * space - * @param[in] distribution optional, the 1 dimensional distribution to associate - * to the parameter. If NULL is passed, the default - * distribution of the parameter is used. - * @return #CCS_RESULT_SUCCESS on success - * @return #CCS_RESULT_ERROR_INVALID_OBJECT if \p configuration_space is not a - * valid CCS configuration space; or \p parameter is not a valid CCS parameter; - * or if distribution is given and distribution is not a valid CCS distribution - * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if \p parameter's type is - * CCS_PARAMETER_TYPE_STRING; or if \p parameter is already in the - * configuration space - * @return #CCS_RESULT_ERROR_INVALID_DISTRIBUTION if \p distribution has more - * than one dimension - * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if a memory could not be allocated to - * store the additional parameter and associated data structures - * @remarks - * This function is NOT thread-safe - */ -extern ccs_result_t -ccs_configuration_space_add_parameter( - ccs_configuration_space_t configuration_space, - ccs_parameter_t parameter, - ccs_distribution_t distribution); - -/** - * Add parameters to the configuration space. - * @param[in,out] configuration_space - * @param[in] num_parameters the number of provided parameters - * @param[in] parameters an array of \p num_parameters parameters - * to add to the configuration space - * @param[in] distributions optional, an array of \p num_parameters - * distributions. If NULL, parameter's default - * distributions are used. If the array is provided - * each distribution is optional, and NULL can be - * provided to use the default distribution for a - * specific parameter - * @return #CCS_RESULT_SUCCESS on success - * @return #CCS_RESULT_ERROR_INVALID_OBJECT if \p configuration_space is not a - * valid CCS configuration space; or a parameter is not a valid CCS parameter; - * or if a given distribution is not a valid CCS distribution - * @return #CCS_RESULT_ERROR_INVALID_VALUE if \p parameters is NULL and \p - * num_parameters is greater than 0 - * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if a parameter's type is - * CCS_PARAMETER_TYPE_STRING; or if a parameter is already in the configuration - * space; or if a parameter with the same name already exists in the - * configuration space - * @return #CCS_RESULT_ERROR_INVALID_DISTRIBUTION if a distribution has more - * than one dimension - * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if memory could not be allocated to - * store additional parameters and associated data structures - * @remarks - * This function is NOT thread-safe - */ -extern ccs_result_t -ccs_configuration_space_add_parameters( - ccs_configuration_space_t configuration_space, - size_t num_parameters, - ccs_parameter_t *parameters, - ccs_distribution_t *distributions); - /** * Set the distribution of one or more parameters. Existing distributions * are discarded, and if a parameter is left without a distribution it's @@ -163,7 +110,7 @@ ccs_configuration_space_add_parameters( * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if a memory could not be allocated to * store additional parameters and associated data structures * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_configuration_space_set_distribution( @@ -403,7 +350,7 @@ ccs_configuration_space_validate_value( * @return #CCS_RESULT_ERROR_INVALID_GRAPH if the addition of the condition * would cause the dependency graph to become invalid (cyclic) * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_configuration_space_set_condition( @@ -480,7 +427,7 @@ ccs_configuration_space_get_conditions( * @return #CCS_RESULT_ERROR_INVALID_CONFIGURATION if adding the forbidden * clause would render the default configuration invalid * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_configuration_space_add_forbidden_clause( @@ -506,7 +453,7 @@ ccs_configuration_space_add_forbidden_clause( * @return #CCS_RESULT_ERROR_INVALID_CONFIGURATION if adding one of the provided * forbidden clause would render the default configuration invalid * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_configuration_space_add_forbidden_clauses( @@ -666,7 +613,7 @@ ccs_configuration_space_get_default_configuration( * @return #CCS_RESULT_ERROR_INVALID_GRAPH if the graph of constraints could * not be previsoulsy generated * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_configuration_space_sample( @@ -697,7 +644,7 @@ ccs_configuration_space_sample( * @return #CCS_RESULT_ERROR_INVALID_GRAPH if the graph of constraints could * not be previsoulsy generated * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_configuration_space_samples( diff --git a/include/cconfigspace/features_space.h b/include/cconfigspace/features_space.h index ff1c8183..d67589b0 100644 --- a/include/cconfigspace/features_space.h +++ b/include/cconfigspace/features_space.h @@ -12,13 +12,18 @@ extern "C" { */ /** - * Create a new empty features space. + * Create a new features space. * @param[in] name pointer to a string that will be copied internally * @param[out] features_space_ret a pointer to the variable that will hold * the newly created features space * @return #CCS_RESULT_SUCCESS on success * @return #CCS_RESULT_ERROR_INVALID_VALUE if \p name is NULL; or if \p - * features_space_ret is NULL + * features_space_ret is NULL; or if \p parameters is NULL; or if \p + * num_parameters is NULL + * @return #CCS_RESULT_ERROR_INVALID_OBJECT if a parameter is not a valid CCS + * parameter + * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if a parameter appears more than + * once in \p parameters; or if two or more parameters share the same name * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if there was a lack of memory to * allocate the new features space * @remarks @@ -27,6 +32,8 @@ extern "C" { extern ccs_result_t ccs_create_features_space( const char *name, + size_t num_parameters, + ccs_parameter_t *parameters, ccs_features_space_t *features_space_ret); /** @@ -46,52 +53,6 @@ ccs_features_space_get_name( ccs_features_space_t features_space, const char **name_ret); -/** - * Add a parameter to the features space. - * @param[in,out] features_space - * @param[in] parameter the parameter to add to the features - * space - * @return #CCS_RESULT_SUCCESS on success - * @return #CCS_RESULT_ERROR_INVALID_OBJECT if \p features_space is not a valid - * CCS features space; or \p parameter is not a valid CCS parameter - * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if \p parameter is already in - * the features space; or if a parameter with the same name already exists in - * the features space - * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if a memory could not be allocated to - * store the additional parameter and associated data structures - * @remarks - * This function is NOT thread-safe - */ -extern ccs_result_t -ccs_features_space_add_parameter( - ccs_features_space_t features_space, - ccs_parameter_t parameter); - -/** - * Add parameters to the features space. - * @param[in,out] features_space - * @param[in] num_parameters the number of provided parameters - * @param[in] parameters an array of \p num_parameters parameters - * to add to the features space - * @return #CCS_RESULT_SUCCESS on success - * @return #CCS_RESULT_ERROR_INVALID_OBJECT if \p features_space is not a valid - * CCS features space; or a parameter is not a valid CCS parameter - * @return #CCS_RESULT_ERROR_INVALID_VALUE if \p parameters is NULL and \p - * num_parameters is greater than 0 - * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if a parameter is already in the - * features space; or if a parameter with the same name already exists in the - * features space - * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if memory could not be allocated to - * store additional parameters and associated data structures - * @remarks - * This function is NOT thread-safe - */ -extern ccs_result_t -ccs_features_space_add_parameters( - ccs_features_space_t features_space, - size_t num_parameters, - ccs_parameter_t *parameters); - /** * Get the number of parameters in a features space. * @param[in] features_space diff --git a/include/cconfigspace/objective_space.h b/include/cconfigspace/objective_space.h index 9fcbab8b..dcfed1d6 100644 --- a/include/cconfigspace/objective_space.h +++ b/include/cconfigspace/objective_space.h @@ -32,13 +32,18 @@ enum ccs_objective_type_e { typedef enum ccs_objective_type_e ccs_objective_type_t; /** - * Create a new empty objective space. + * Create a new objective space. * @param[in] name pointer to a string that will be copied internally * @param[out] objective_space_ret a pointer to the variable that will hold * the newly created objective space * @return #CCS_RESULT_SUCCESS on success * @return #CCS_RESULT_ERROR_INVALID_VALUE if \p name is NULL; or if \p - * objective_space_ret is NULL + * objective_space_ret is NULL; or if \p parameters is NULL; or if \p + * num_parameters is NULL + * @return #CCS_RESULT_ERROR_INVALID_OBJECT if a parameter is not a valid CCS + * parameter + * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if a parameter appears more than + * once in \p parameters; or if two or more parameters share the same name * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if there was a lack of memory to * allocate the new objective space * @remarks @@ -47,6 +52,8 @@ typedef enum ccs_objective_type_e ccs_objective_type_t; extern ccs_result_t ccs_create_objective_space( const char *name, + size_t num_parameters, + ccs_parameter_t *parameters, ccs_objective_space_t *objective_space_ret); /** @@ -66,51 +73,6 @@ ccs_objective_space_get_name( ccs_objective_space_t objective_space, const char **name_ret); -/** - * Add a parameter to the objective space. - * @param[in,out] objective_space - * @param[in] parameter the parameter to add to the objective space - * @return #CCS_RESULT_SUCCESS on success - * @return #CCS_RESULT_ERROR_INVALID_OBJECT if \p objective_space is not a valid - * CCS objective space; or \p parameter is not a valid CCS parameter - * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if \p parameter is already in - * the objective space; or if a parameter with the same name already exists in - * the objective space - * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if a memory could not be allocated to - * store the additional parameter and associated data structures - * @remarks - * This function is NOT thread-safe - */ -extern ccs_result_t -ccs_objective_space_add_parameter( - ccs_objective_space_t objective_space, - ccs_parameter_t parameter); - -/** - * Add parameters to the objective space. - * @param[in,out] objective_space - * @param[in] num_parameters the number of provided parameters - * @param[in] parameters an array of \p num_parameters parameters to add to the - * objective space - * @return #CCS_RESULT_SUCCESS on success - * @return #CCS_RESULT_ERROR_INVALID_OBJECT if \p objective_space is not a valid - * CCS objective space; or a parameter is not a valid CCS parameter - * @return #CCS_RESULT_ERROR_INVALID_VALUE if \p parameters is NULL and \p - * num_parameters is greater than 0 - * @return #CCS_RESULT_ERROR_INVALID_PARAMETER if a parameter is already in the - * objective space; or if a parameter with the same name already exists in the - * objective space - * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if memory could not be allocated to - * store additional parameters and associated data structures - * @remarks - * This function is NOT thread-safe - */ -extern ccs_result_t -ccs_objective_space_add_parameters( - ccs_objective_space_t objective_space, - size_t num_parameters, - ccs_parameter_t *parameters); - /** * Get the number of parameters in a objective space. * @param[in] objective_space @@ -340,7 +302,7 @@ ccs_objective_space_validate_value( * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if there was not enough memory to * allocate internal data structures * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_objective_space_add_objective( @@ -366,7 +328,7 @@ ccs_objective_space_add_objective( * @return #CCS_RESULT_ERROR_OUT_OF_MEMORY if there was not enough memory to * allocate internal data structures * @remarks - * This function is NOT thread-safe + * This function is thread-safe */ extern ccs_result_t ccs_objective_space_add_objectives( diff --git a/samples/test_python.c b/samples/test_python.c index 5f1394f8..a4c41189 100644 --- a/samples/test_python.c +++ b/samples/test_python.c @@ -20,29 +20,24 @@ void create_problem(ccs_configuration_space_t *cs, ccs_objective_space_t *os) { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_configuration_space_t cspace; ccs_objective_space_t ospace; ccs_expression_t expression; ccs_result_t err; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); parameter3 = create_numerical("z", -CCS_INFINITY, CCS_INFINITY); err = ccs_create_variable(parameter3, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE); diff --git a/samples/test_python.py b/samples/test_python.py index 22562c9e..69acb588 100644 --- a/samples/test_python.py +++ b/samples/test_python.py @@ -56,15 +56,13 @@ def create_test_tuner(cs_ptr, os_ptr): return t def create_tuning_problem(): - cs = ccs.ConfigurationSpace(name = "cspace") h1 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) h2 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) h3 = ccs.NumericalParameter.Float(lower = -5.0, upper = 5.0) - cs.add_parameters([h1, h2, h3]) - os = ccs.ObjectiveSpace(name = "ospace") + cs = ccs.ConfigurationSpace(name = "cspace", parameters = [h1, h2, h3]) v1 = ccs.NumericalParameter.Float(lower = float('-inf'), upper = float('inf')) v2 = ccs.NumericalParameter.Float(lower = float('-inf'), upper = float('inf')) - os.add_parameters([v1, v2]) + os = ccs.ObjectiveSpace(name = "ospace", parameters = [v1, v2]) e1 = ccs.Expression.Variable(parameter = v1) e2 = ccs.Expression.Variable(parameter = v2) os.add_objectives( [e1, e2] ) diff --git a/samples/test_ruby.c b/samples/test_ruby.c index e9f6c6f5..bad869e2 100644 --- a/samples/test_ruby.c +++ b/samples/test_ruby.c @@ -29,29 +29,24 @@ void create_problem(ccs_configuration_space_t *cs, ccs_objective_space_t *os) { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_configuration_space_t cspace; ccs_objective_space_t ospace; ccs_expression_t expression; ccs_result_t err; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); parameter3 = create_numerical("z", -CCS_INFINITY, CCS_INFINITY); err = ccs_create_variable(parameter3, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE); diff --git a/samples/test_ruby.rb b/samples/test_ruby.rb index 0e858d54..7fa99893 100644 --- a/samples/test_ruby.rb +++ b/samples/test_ruby.rb @@ -53,15 +53,13 @@ def create_test_tuner(cs_ptr, os_ptr) end def create_tuning_problem - cs = CCS::ConfigurationSpace::new(name: "cspace") h1 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) h2 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) h3 = CCS::NumericalParameter::Float.new(lower: -5.0, upper: 5.0) - cs.add_parameters [h1, h2, h3] - os = CCS::ObjectiveSpace::new(name: "ospace") + cs = CCS::ConfigurationSpace::new(name: "cspace", parameters: [h1, h2, h3]) v1 = CCS::NumericalParameter::Float.new(lower: -Float::INFINITY, upper: Float::INFINITY) v2 = CCS::NumericalParameter::Float.new(lower: -Float::INFINITY, upper: Float::INFINITY) - os.add_parameters [v1, v2] + os = CCS::ObjectiveSpace::new(name: "ospace", parameters: [v1, v2]) e1 = CCS::Expression::Variable::new(parameter: v1) e2 = CCS::Expression::Variable::new(parameter: v2) os.add_objectives( [e1, e2] ) diff --git a/src/cconfigspace.c b/src/cconfigspace.c index 6e0f3826..b032c16d 100644 --- a/src/cconfigspace.c +++ b/src/cconfigspace.c @@ -17,9 +17,9 @@ const ccs_version_t ccs_version = { CCS_VERSION_MAJOR}; #if CCS_THREAD_SAFE -static pthread_mutex_t _ccs_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t _ccs_mutex = PTHREAD_MUTEX_INITIALIZER; #endif -static int32_t _ccs_refcount = 0; +static int32_t _ccs_refcount = 0; ccs_result_t ccs_init() @@ -169,7 +169,7 @@ ccs_object_get_user_data(ccs_object_t object, void **user_data_ret) CCS_CHECK_PTR(user_data_ret); _ccs_object_internal_t *obj = (_ccs_object_internal_t *)object; CCS_RWLOCK_RDLOCK(obj->lock); - *user_data_ret = obj->user_data; + *user_data_ret = obj->user_data; CCS_RWLOCK_UNLOCK(obj->lock); return CCS_RESULT_SUCCESS; } diff --git a/src/cconfigspace_internal.h b/src/cconfigspace_internal.h index 3f437560..c7e83ffa 100644 --- a/src/cconfigspace_internal.h +++ b/src/cconfigspace_internal.h @@ -54,7 +54,11 @@ _ccs_interval_include(ccs_interval_t *interval, ccs_numeric_t value) #define CCS_THREAD_SAFE 0 #endif -static inline int _ccs_do_nothing(void) { return 0; } +static inline int +_ccs_do_nothing(void) +{ + return 0; +} #if CCS_THREAD_SAFE @@ -365,12 +369,12 @@ struct _ccs_object_callback_s { typedef struct _ccs_object_callback_s _ccs_object_callback_t; struct _ccs_object_internal_s { - ccs_object_type_t type; - int32_t refcount; - void *user_data; + ccs_object_type_t type; + int32_t refcount; + void *user_data; #if CCS_THREAD_SAFE - pthread_mutex_t mutex; - pthread_rwlock_t lock; + pthread_mutex_t mutex; + pthread_rwlock_t lock; #endif UT_array *callbacks; _ccs_object_ops_t *ops; @@ -392,12 +396,12 @@ _ccs_object_init( ccs_object_type_t t, _ccs_object_ops_t *ops) { - o->type = t; - o->refcount = 1; - o->user_data = NULL; + o->type = t; + o->refcount = 1; + o->user_data = NULL; #if CCS_THREAD_SAFE - o->mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER; - o->lock = (pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER; + o->mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER; + o->lock = (pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER; #endif o->callbacks = NULL; o->ops = ops; diff --git a/src/configuration_space.c b/src/configuration_space.c index 40816543..26563d6b 100644 --- a/src/configuration_space.c +++ b/src/configuration_space.c @@ -259,19 +259,30 @@ _ccs_configuration_space_serialize_size( size_t *cum_size, _ccs_object_serialize_options_t *opts) { + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(object); switch (format) { case CCS_SERIALIZE_FORMAT_BINARY: - CCS_VALIDATE(_ccs_serialize_bin_size_ccs_configuration_space( - (ccs_configuration_space_t)object, cum_size, opts)); + CCS_VALIDATE_ERR_GOTO( + err, + _ccs_serialize_bin_size_ccs_configuration_space( + (ccs_configuration_space_t)object, cum_size, + opts), + end); break; default: - CCS_RAISE( - CCS_RESULT_ERROR_INVALID_VALUE, + CCS_RAISE_ERR_GOTO( + err, CCS_RESULT_ERROR_INVALID_VALUE, end, "Unsupported serialization format: %d", format); } - CCS_VALIDATE(_ccs_object_serialize_user_data_size( - object, format, cum_size, opts)); - return CCS_RESULT_SUCCESS; + CCS_VALIDATE_ERR_GOTO( + err, + _ccs_object_serialize_user_data_size( + object, format, cum_size, opts), + end); +end: + CCS_OBJ_UNLOCK(object); + return err; } static ccs_result_t @@ -282,20 +293,30 @@ _ccs_configuration_space_serialize( char **buffer, _ccs_object_serialize_options_t *opts) { + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(object); switch (format) { case CCS_SERIALIZE_FORMAT_BINARY: - CCS_VALIDATE(_ccs_serialize_bin_ccs_configuration_space( - (ccs_configuration_space_t)object, buffer_size, buffer, - opts)); + CCS_VALIDATE_ERR_GOTO( + err, + _ccs_serialize_bin_ccs_configuration_space( + (ccs_configuration_space_t)object, buffer_size, + buffer, opts), + end); break; default: - CCS_RAISE( - CCS_RESULT_ERROR_INVALID_VALUE, + CCS_RAISE_ERR_GOTO( + err, CCS_RESULT_ERROR_INVALID_VALUE, end, "Unsupported serialization format: %d", format); } - CCS_VALIDATE(_ccs_object_serialize_user_data( - object, format, buffer_size, buffer, opts)); - return CCS_RESULT_SUCCESS; + CCS_VALIDATE_ERR_GOTO( + err, + _ccs_object_serialize_user_data( + object, format, buffer_size, buffer, opts), + end); +end: + CCS_OBJ_UNLOCK(object); + return err; } static _ccs_configuration_space_ops_t _configuration_space_ops = { @@ -319,98 +340,6 @@ static const UT_icd _forbidden_clauses_icd = { static UT_icd _size_t_icd = {sizeof(size_t), NULL, NULL, NULL}; -#undef utarray_oom -#define utarray_oom() \ - { \ - ccs_release_object(config_space->data->rng); \ - CCS_RAISE_ERR_GOTO( \ - err, CCS_RESULT_ERROR_OUT_OF_MEMORY, errarrays, \ - "Out of memory to allocate array"); \ - } -ccs_result_t -ccs_create_configuration_space( - const char *name, - ccs_configuration_space_t *configuration_space_ret) -{ - CCS_CHECK_PTR(name); - CCS_CHECK_PTR(configuration_space_ret); - ccs_result_t err; - uintptr_t mem = (uintptr_t)calloc( - 1, sizeof(struct _ccs_configuration_space_s) + - sizeof(struct _ccs_configuration_space_data_s) + - strlen(name) + 1); - CCS_REFUTE(!mem, CCS_RESULT_ERROR_OUT_OF_MEMORY); - ccs_rng_t rng; - CCS_VALIDATE_ERR_GOTO(err, ccs_create_rng(&rng), errmem); - - ccs_configuration_space_t config_space; - config_space = (ccs_configuration_space_t)mem; - _ccs_object_init( - &(config_space->obj), CCS_OBJECT_TYPE_CONFIGURATION_SPACE, - (_ccs_object_ops_t *)&_configuration_space_ops); - config_space->data = - (struct _ccs_configuration_space_data_s - *)(mem + sizeof(struct _ccs_configuration_space_s)); - config_space->data->name = - (const char - *)(mem + sizeof(struct _ccs_configuration_space_s) + sizeof(struct _ccs_configuration_space_data_s)); - config_space->data->rng = rng; - utarray_new(config_space->data->parameters, &_parameter_wrapper_icd); - utarray_new( - config_space->data->forbidden_clauses, &_forbidden_clauses_icd); - utarray_new(config_space->data->sorted_indexes, &_size_t_icd); - config_space->data->graph_ok = CCS_TRUE; - strcpy((char *)(config_space->data->name), name); - *configuration_space_ret = config_space; - return CCS_RESULT_SUCCESS; -errarrays: - if (config_space->data->parameters) - utarray_free(config_space->data->parameters); - if (config_space->data->forbidden_clauses) - utarray_free(config_space->data->forbidden_clauses); - if (config_space->data->sorted_indexes) - utarray_free(config_space->data->sorted_indexes); -errmem: - free((void *)mem); - return err; -} - -ccs_result_t -ccs_configuration_space_get_name( - ccs_configuration_space_t configuration_space, - const char **name_ret) -{ - CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); - CCS_VALIDATE(_ccs_context_get_name( - (ccs_context_t)configuration_space, name_ret)); - return CCS_RESULT_SUCCESS; -} - -ccs_result_t -ccs_configuration_space_set_rng( - ccs_configuration_space_t configuration_space, - ccs_rng_t rng) -{ - CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); - CCS_CHECK_OBJ(rng, CCS_OBJECT_TYPE_RNG); - CCS_VALIDATE(ccs_retain_object(rng)); - ccs_rng_t tmp = configuration_space->data->rng; - configuration_space->data->rng = rng; - CCS_VALIDATE(ccs_release_object(tmp)); - return CCS_RESULT_SUCCESS; -} - -ccs_result_t -ccs_configuration_space_get_rng( - ccs_configuration_space_t configuration_space, - ccs_rng_t *rng_ret) -{ - CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); - CCS_CHECK_PTR(rng_ret); - *rng_ret = configuration_space->data->rng; - return CCS_RESULT_SUCCESS; -} - #undef utarray_oom #define utarray_oom() \ { \ @@ -426,13 +355,11 @@ ccs_configuration_space_get_rng( err, CCS_RESULT_ERROR_OUT_OF_MEMORY, errorutarray, \ "Out of memory to allocate hash"); \ } -ccs_result_t -ccs_configuration_space_add_parameter( +static ccs_result_t +_ccs_configuration_space_add_parameter( ccs_configuration_space_t configuration_space, - ccs_parameter_t parameter, - ccs_distribution_t distribution) + ccs_parameter_t parameter) { - CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); CCS_CHECK_OBJ(parameter, CCS_OBJECT_TYPE_PARAMETER); ccs_result_t err; ccs_parameter_type_t type; @@ -459,31 +386,19 @@ ccs_configuration_space_add_parameter( size_t dimension; _ccs_parameter_wrapper_cs_t parameter_wrapper; _ccs_distribution_wrapper_t *distrib_wrapper; + ccs_distribution_t distribution; uintptr_t pmem; parameter_wrapper.parameter = parameter; CCS_VALIDATE(ccs_retain_object(parameter)); - if (distribution) { - CCS_VALIDATE_ERR_GOTO( - err, - ccs_distribution_get_dimension(distribution, &dimension), - errorparameter); - CCS_REFUTE_ERR_GOTO( - err, dimension != 1, - CCS_RESULT_ERROR_INVALID_DISTRIBUTION, errorparameter); - CCS_VALIDATE_ERR_GOTO( - err, ccs_retain_object(distribution), errorparameter); - } else { - CCS_VALIDATE_ERR_GOTO( - err, - ccs_parameter_get_default_distribution( - parameter, &distribution), - errorparameter); - dimension = 1; - } - pmem = (uintptr_t)malloc( - sizeof(_ccs_distribution_wrapper_t) + - sizeof(size_t) * dimension); + CCS_VALIDATE_ERR_GOTO( + err, + ccs_parameter_get_default_distribution(parameter, &distribution), + errorparameter); + dimension = 1; + pmem = (uintptr_t)malloc( + sizeof(_ccs_distribution_wrapper_t) + + sizeof(size_t) * dimension); CCS_REFUTE_ERR_GOTO( err, !pmem, CCS_RESULT_ERROR_OUT_OF_MEMORY, errordistrib); distrib_wrapper = (_ccs_distribution_wrapper_t *)pmem; @@ -544,6 +459,131 @@ ccs_configuration_space_add_parameter( #undef utarray_oom #define utarray_oom() exit(-1) +static ccs_result_t +_ccs_configuration_space_add_parameters( + ccs_configuration_space_t configuration_space, + size_t num_parameters, + ccs_parameter_t *parameters) +{ + for (size_t i = 0; i < num_parameters; i++) + CCS_VALIDATE(_ccs_configuration_space_add_parameter( + configuration_space, parameters[i])); + return CCS_RESULT_SUCCESS; +} + +#undef utarray_oom +#define utarray_oom() \ + { \ + ccs_release_object(config_space->data->rng); \ + CCS_RAISE_ERR_GOTO( \ + err, CCS_RESULT_ERROR_OUT_OF_MEMORY, errarrays, \ + "Out of memory to allocate array"); \ + } + +ccs_result_t +ccs_create_configuration_space( + const char *name, + size_t num_parameters, + ccs_parameter_t *parameters, + ccs_configuration_space_t *configuration_space_ret) +{ + CCS_CHECK_PTR(name); + CCS_CHECK_PTR(configuration_space_ret); + CCS_REFUTE(!num_parameters, CCS_RESULT_ERROR_INVALID_VALUE); + CCS_CHECK_PTR(parameters); + ccs_result_t err; + uintptr_t mem = (uintptr_t)calloc( + 1, sizeof(struct _ccs_configuration_space_s) + + sizeof(struct _ccs_configuration_space_data_s) + + strlen(name) + 1); + CCS_REFUTE(!mem, CCS_RESULT_ERROR_OUT_OF_MEMORY); + ccs_rng_t rng; + CCS_VALIDATE_ERR_GOTO(err, ccs_create_rng(&rng), errmem); + + ccs_configuration_space_t config_space; + config_space = (ccs_configuration_space_t)mem; + _ccs_object_init( + &(config_space->obj), CCS_OBJECT_TYPE_CONFIGURATION_SPACE, + (_ccs_object_ops_t *)&_configuration_space_ops); + config_space->data = + (struct _ccs_configuration_space_data_s + *)(mem + sizeof(struct _ccs_configuration_space_s)); + config_space->data->name = + (const char + *)(mem + sizeof(struct _ccs_configuration_space_s) + sizeof(struct _ccs_configuration_space_data_s)); + config_space->data->rng = rng; + utarray_new(config_space->data->parameters, &_parameter_wrapper_icd); + utarray_new( + config_space->data->forbidden_clauses, &_forbidden_clauses_icd); + utarray_new(config_space->data->sorted_indexes, &_size_t_icd); + config_space->data->graph_ok = CCS_TRUE; + strcpy((char *)(config_space->data->name), name); + *configuration_space_ret = config_space; + CCS_VALIDATE_ERR_GOTO( + err, + _ccs_configuration_space_add_parameters( + config_space, num_parameters, parameters), + errparams); + return CCS_RESULT_SUCCESS; +errarrays: + if (config_space->data->parameters) + utarray_free(config_space->data->parameters); + if (config_space->data->forbidden_clauses) + utarray_free(config_space->data->forbidden_clauses); + if (config_space->data->sorted_indexes) + utarray_free(config_space->data->sorted_indexes); + ccs_release_object(config_space->data->rng); +errmem: + free((void *)mem); + return err; +errparams: + _ccs_configuration_space_del(config_space); + free((void *)mem); + return err; +} +#undef utarray_oom +#define utarray_oom() exit(-1) + +ccs_result_t +ccs_configuration_space_get_name( + ccs_configuration_space_t configuration_space, + const char **name_ret) +{ + CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); + CCS_VALIDATE(_ccs_context_get_name( + (ccs_context_t)configuration_space, name_ret)); + return CCS_RESULT_SUCCESS; +} + +ccs_result_t +ccs_configuration_space_set_rng( + ccs_configuration_space_t configuration_space, + ccs_rng_t rng) +{ + CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); + CCS_CHECK_OBJ(rng, CCS_OBJECT_TYPE_RNG); + CCS_VALIDATE(ccs_retain_object(rng)); + CCS_OBJ_WRLOCK(configuration_space); + ccs_rng_t tmp = configuration_space->data->rng; + configuration_space->data->rng = rng; + CCS_OBJ_UNLOCK(configuration_space); + CCS_VALIDATE(ccs_release_object(tmp)); + return CCS_RESULT_SUCCESS; +} + +ccs_result_t +ccs_configuration_space_get_rng( + ccs_configuration_space_t configuration_space, + ccs_rng_t *rng_ret) +{ + CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); + CCS_CHECK_PTR(rng_ret); + CCS_OBJ_RDLOCK(configuration_space); + *rng_ret = configuration_space->data->rng; + CCS_OBJ_UNLOCK(configuration_space); + return CCS_RESULT_SUCCESS; +} + ccs_result_t ccs_configuration_space_set_distribution( ccs_configuration_space_t configuration_space, @@ -554,44 +594,49 @@ ccs_configuration_space_set_distribution( CCS_CHECK_OBJ(distribution, CCS_OBJECT_TYPE_DISTRIBUTION); CCS_CHECK_PTR(indexes); - _ccs_distribution_wrapper_t *dwrapper; - _ccs_parameter_wrapper_cs_t *hwrapper; - ccs_result_t err; + _ccs_distribution_wrapper_t *dwrapper; + _ccs_distribution_wrapper_t **p_dwrappers_to_del; + _ccs_distribution_wrapper_t **p_dwrappers_to_add; + _ccs_parameter_wrapper_cs_t *hwrapper; + ccs_result_t err; + size_t dim; + uintptr_t mem; + uintptr_t dmem; + uintptr_t cur_mem; + size_t *parameters_without_distrib; + size_t to_add_count = 0; + size_t to_del_count = 0; + size_t without_distrib_count = 0; + + CCS_VALIDATE(ccs_distribution_get_dimension(distribution, &dim)); + CCS_OBJ_WRLOCK(configuration_space); UT_array *parameters = configuration_space->data->parameters; size_t num_parameters = utarray_len(parameters); - size_t dim; - CCS_VALIDATE(ccs_distribution_get_dimension(distribution, &dim)); for (size_t i = 0; i < dim; i++) { - CCS_REFUTE( - indexes[i] >= num_parameters, - CCS_RESULT_ERROR_INVALID_VALUE); + CCS_REFUTE_ERR_GOTO( + err, indexes[i] >= num_parameters, + CCS_RESULT_ERROR_INVALID_VALUE, errdistrib); // Check duplicate entries for (size_t j = i + 1; j < dim; j++) - CCS_REFUTE( - indexes[i] == indexes[j], - CCS_RESULT_ERROR_INVALID_VALUE); + CCS_REFUTE_ERR_GOTO( + err, indexes[i] == indexes[j], + CCS_RESULT_ERROR_INVALID_VALUE, errdistrib); } - uintptr_t cur_mem; - uintptr_t mem = (uintptr_t)malloc( + mem = (uintptr_t)malloc( sizeof(void *) * num_parameters * 2 + sizeof(size_t) * num_parameters); - CCS_REFUTE(!mem, CCS_RESULT_ERROR_OUT_OF_MEMORY); - cur_mem = mem; - _ccs_distribution_wrapper_t **p_dwrappers_to_del = - (_ccs_distribution_wrapper_t **)cur_mem; + CCS_REFUTE_ERR_GOTO( + err, !mem, CCS_RESULT_ERROR_OUT_OF_MEMORY, errdistrib); + cur_mem = mem; + p_dwrappers_to_del = (_ccs_distribution_wrapper_t **)cur_mem; cur_mem += sizeof(_ccs_distribution_wrapper_t *) * num_parameters; - _ccs_distribution_wrapper_t **p_dwrappers_to_add = - (_ccs_distribution_wrapper_t **)cur_mem; + p_dwrappers_to_add = (_ccs_distribution_wrapper_t **)cur_mem; cur_mem += sizeof(_ccs_distribution_wrapper_t *) * num_parameters; - size_t *parameters_without_distrib = (size_t *)cur_mem; + parameters_without_distrib = (size_t *)cur_mem; cur_mem += sizeof(size_t) * num_parameters; - size_t to_add_count = 0; - size_t to_del_count = 0; - size_t without_distrib_count = 0; - for (size_t i = 0; i < dim; i++) { int add = 1; hwrapper = (_ccs_parameter_wrapper_cs_t *)utarray_eltptr( @@ -612,7 +657,7 @@ ccs_configuration_space_set_distribution( } } - uintptr_t dmem = (uintptr_t)malloc( + dmem = (uintptr_t)malloc( sizeof(_ccs_distribution_wrapper_t) + sizeof(size_t) * dim); CCS_REFUTE_ERR_GOTO(err, !dmem, CCS_RESULT_ERROR_OUT_OF_MEMORY, memory); @@ -677,6 +722,7 @@ ccs_configuration_space_set_distribution( } free((void *)mem); + CCS_OBJ_UNLOCK(configuration_space); return CCS_RESULT_SUCCESS; dwrappers: for (size_t i = 0; i < to_add_count; i++) { @@ -688,6 +734,8 @@ ccs_configuration_space_set_distribution( free((void *)dmem); memory: free((void *)mem); +errdistrib: + CCS_OBJ_UNLOCK(configuration_space); return err; } @@ -698,37 +746,22 @@ ccs_configuration_space_get_parameter_distribution( ccs_distribution_t *distribution_ret, size_t *index_ret) { + ccs_result_t err = CCS_RESULT_SUCCESS; CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); CCS_CHECK_PTR(distribution_ret); CCS_CHECK_PTR(index_ret); + CCS_OBJ_RDLOCK(configuration_space); _ccs_parameter_wrapper_cs_t *wrapper = (_ccs_parameter_wrapper_cs_t *)utarray_eltptr( configuration_space->data->parameters, (unsigned int)index); - CCS_REFUTE(!wrapper, CCS_RESULT_ERROR_OUT_OF_BOUNDS); + CCS_REFUTE_ERR_GOTO(err, !wrapper, CCS_RESULT_ERROR_OUT_OF_BOUNDS, end); *distribution_ret = wrapper->distribution->distribution; *index_ret = wrapper->distribution_index; - return CCS_RESULT_SUCCESS; -} - -ccs_result_t -ccs_configuration_space_add_parameters( - ccs_configuration_space_t configuration_space, - size_t num_parameters, - ccs_parameter_t *parameters, - ccs_distribution_t *distributions) -{ - CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); - CCS_CHECK_ARY(num_parameters, parameters); - for (size_t i = 0; i < num_parameters; i++) { - ccs_distribution_t distribution = NULL; - if (distributions) - distribution = distributions[i]; - CCS_VALIDATE(ccs_configuration_space_add_parameter( - configuration_space, parameters[i], distribution)); - } - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(configuration_space); + return err; } ccs_result_t @@ -973,13 +1006,20 @@ ccs_configuration_space_check_configuration( CCS_REFUTE( configuration->data->configuration_space != configuration_space, CCS_RESULT_ERROR_INVALID_CONFIGURATION); - CCS_REFUTE( - !configuration_space->data->graph_ok, - CCS_RESULT_ERROR_INVALID_GRAPH); - CCS_VALIDATE(_check_configuration( - configuration_space, configuration->data->num_values, - configuration->data->values, is_valid_ret)); - return CCS_RESULT_SUCCESS; + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(configuration_space); + CCS_REFUTE_ERR_GOTO( + err, !configuration_space->data->graph_ok, + CCS_RESULT_ERROR_INVALID_GRAPH, end); + CCS_VALIDATE_ERR_GOTO( + err, + _check_configuration( + configuration_space, configuration->data->num_values, + configuration->data->values, is_valid_ret), + end); +end: + CCS_OBJ_UNLOCK(configuration_space); + return err; } ccs_result_t @@ -991,12 +1031,19 @@ ccs_configuration_space_check_configuration_values( { CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); CCS_CHECK_ARY(num_values, values); - CCS_REFUTE( - !configuration_space->data->graph_ok, - CCS_RESULT_ERROR_INVALID_GRAPH); - CCS_VALIDATE(_check_configuration( - configuration_space, num_values, values, is_valid_ret)); - return CCS_RESULT_SUCCESS; + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(configuration_space); + CCS_REFUTE_ERR_GOTO( + err, !configuration_space->data->graph_ok, + CCS_RESULT_ERROR_INVALID_GRAPH, end); + CCS_VALIDATE_ERR_GOTO( + err, + _check_configuration( + configuration_space, num_values, values, is_valid_ret), + end); +end: + CCS_OBJ_UNLOCK(configuration_space); + return err; } static ccs_result_t @@ -1061,14 +1108,17 @@ ccs_configuration_space_sample( CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); CCS_CHECK_PTR(configuration_ret); ccs_result_t err; + ccs_bool_t found; + int counter = 0; ccs_configuration_t config; - CCS_REFUTE( - !configuration_space->data->graph_ok, - CCS_RESULT_ERROR_INVALID_GRAPH); - CCS_VALIDATE(ccs_create_configuration( - configuration_space, 0, NULL, &config)); - ccs_bool_t found; - int counter = 0; + CCS_OBJ_WRLOCK(configuration_space); + CCS_REFUTE_ERR_GOTO( + err, !configuration_space->data->graph_ok, + CCS_RESULT_ERROR_INVALID_GRAPH, errgraph); + CCS_VALIDATE_ERR_GOTO( + err, + ccs_create_configuration(configuration_space, 0, NULL, &config), + errgraph); do { CCS_VALIDATE_ERR_GOTO( err, _sample(configuration_space, config, &found), @@ -1078,9 +1128,12 @@ ccs_configuration_space_sample( CCS_REFUTE_ERR_GOTO( err, !found, CCS_RESULT_ERROR_SAMPLING_UNSUCCESSFUL, errc); *configuration_ret = config; + CCS_OBJ_UNLOCK(configuration_space); return CCS_RESULT_SUCCESS; errc: ccs_release_object(config); +errgraph: + CCS_OBJ_UNLOCK(configuration_space); return err; } @@ -1094,22 +1147,26 @@ ccs_configuration_space_samples( CCS_CHECK_ARY(num_configurations, configurations); if (!num_configurations) return CCS_RESULT_SUCCESS; - ccs_result_t err; - CCS_REFUTE( - !configuration_space->data->graph_ok, - CCS_RESULT_ERROR_INVALID_GRAPH); + ccs_result_t err; size_t counter = 0; size_t count = 0; ccs_bool_t found; ccs_configuration_t config = NULL; + CCS_OBJ_WRLOCK(configuration_space); + CCS_REFUTE_ERR_GOTO( + err, !configuration_space->data->graph_ok, + CCS_RESULT_ERROR_INVALID_GRAPH, errgraph); for (size_t i = 0; i < num_configurations; i++) configurations[i] = NULL; while (count < num_configurations && counter < 100 * num_configurations) { if (!config) - CCS_VALIDATE(ccs_create_configuration( - configuration_space, 0, NULL, &config)); + CCS_VALIDATE_ERR_GOTO( + err, + ccs_create_configuration( + configuration_space, 0, NULL, &config), + errgraph); CCS_VALIDATE_ERR_GOTO( err, _sample(configuration_space, config, &found), errc); @@ -1122,9 +1179,12 @@ ccs_configuration_space_samples( CCS_REFUTE( count < num_configurations, CCS_RESULT_ERROR_SAMPLING_UNSUCCESSFUL); + CCS_OBJ_UNLOCK(configuration_space); return CCS_RESULT_SUCCESS; errc: ccs_release_object(config); +errgraph: + CCS_OBJ_UNLOCK(configuration_space); return err; } @@ -1321,24 +1381,31 @@ ccs_configuration_space_set_condition( { CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); CCS_CHECK_OBJ(expression, CCS_OBJECT_TYPE_EXPRESSION); + CCS_OBJ_WRLOCK(configuration_space); + ccs_result_t err; _ccs_parameter_wrapper_cs_t *wrapper = (_ccs_parameter_wrapper_cs_t *)utarray_eltptr( configuration_space->data->parameters, (unsigned int)parameter_index); - CCS_REFUTE(!wrapper, CCS_RESULT_ERROR_OUT_OF_BOUNDS); - CCS_REFUTE(wrapper->condition, CCS_RESULT_ERROR_INVALID_PARAMETER); - ccs_result_t err; - CCS_VALIDATE(ccs_retain_object(expression)); + CCS_REFUTE_ERR_GOTO( + err, !wrapper, CCS_RESULT_ERROR_OUT_OF_BOUNDS, errwrapper); + CCS_REFUTE_ERR_GOTO( + err, wrapper->condition, CCS_RESULT_ERROR_INVALID_PARAMETER, + errwrapper); + CCS_VALIDATE_ERR_GOTO(err, ccs_retain_object(expression), errwrapper); wrapper->condition = expression; // Recompute the whole graph for now configuration_space->data->graph_ok = CCS_FALSE; CCS_VALIDATE_ERR_GOTO( err, _generate_constraints(configuration_space), erre); + CCS_OBJ_UNLOCK(configuration_space); return CCS_RESULT_SUCCESS; erre: ccs_release_object(expression); wrapper->condition = NULL; _generate_constraints(configuration_space); +errwrapper: + CCS_OBJ_UNLOCK(configuration_space); return err; } @@ -1350,13 +1417,17 @@ ccs_configuration_space_get_condition( { CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); CCS_CHECK_PTR(expression_ret); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(configuration_space); _ccs_parameter_wrapper_cs_t *wrapper = (_ccs_parameter_wrapper_cs_t *)utarray_eltptr( configuration_space->data->parameters, (unsigned int)parameter_index); - CCS_REFUTE(!wrapper, CCS_RESULT_ERROR_OUT_OF_BOUNDS); + CCS_REFUTE_ERR_GOTO(err, !wrapper, CCS_RESULT_ERROR_OUT_OF_BOUNDS, end); *expression_ret = wrapper->condition; - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(configuration_space); + return err; } ccs_result_t @@ -1371,12 +1442,14 @@ ccs_configuration_space_get_conditions( CCS_REFUTE( !expressions && !num_expressions_ret, CCS_RESULT_ERROR_INVALID_VALUE); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(configuration_space); UT_array *array = configuration_space->data->parameters; size_t num_parameters = utarray_len(array); if (expressions) { - CCS_REFUTE( - num_expressions < num_parameters, - CCS_RESULT_ERROR_INVALID_VALUE); + CCS_REFUTE_ERR_GOTO( + err, num_expressions < num_parameters, + CCS_RESULT_ERROR_INVALID_VALUE, end); _ccs_parameter_wrapper_cs_t *wrapper = NULL; size_t index = 0; while ((wrapper = (_ccs_parameter_wrapper_cs_t *)utarray_next( @@ -1387,7 +1460,9 @@ ccs_configuration_space_get_conditions( } if (num_expressions_ret) *num_expressions_ret = num_parameters; - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(configuration_space); + return err; } #undef utarray_oom @@ -1412,6 +1487,7 @@ ccs_configuration_space_add_forbidden_clause( CCS_VALIDATE(ccs_configuration_space_get_default_configuration( configuration_space, &config)); + CCS_OBJ_WRLOCK(configuration_space); CCS_VALIDATE_ERR_GOTO( err, ccs_expression_eval( @@ -1426,6 +1502,7 @@ ccs_configuration_space_add_forbidden_clause( utarray_push_back( configuration_space->data->forbidden_clauses, &expression); end: + CCS_OBJ_UNLOCK(configuration_space); ccs_release_object(config); return err; } @@ -1454,12 +1531,16 @@ ccs_configuration_space_get_forbidden_clause( { CCS_CHECK_OBJ(configuration_space, CCS_OBJECT_TYPE_CONFIGURATION_SPACE); CCS_CHECK_PTR(expression_ret); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(configuration_space); ccs_expression_t *p_expr = (ccs_expression_t *)utarray_eltptr( configuration_space->data->forbidden_clauses, (unsigned int)index); - CCS_REFUTE(!p_expr, CCS_RESULT_ERROR_OUT_OF_BOUNDS); + CCS_REFUTE_ERR_GOTO(err, !p_expr, CCS_RESULT_ERROR_OUT_OF_BOUNDS, end); *expression_ret = *p_expr; - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(configuration_space); + return err; } ccs_result_t @@ -1474,12 +1555,14 @@ ccs_configuration_space_get_forbidden_clauses( CCS_REFUTE( !expressions && !num_expressions_ret, CCS_RESULT_ERROR_INVALID_VALUE); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(configuration_space); UT_array *array = configuration_space->data->forbidden_clauses; size_t num_forbidden_clauses = utarray_len(array); if (expressions) { - CCS_REFUTE( - num_expressions < num_forbidden_clauses, - CCS_RESULT_ERROR_INVALID_VALUE); + CCS_REFUTE_ERR_GOTO( + err, num_expressions < num_forbidden_clauses, + CCS_RESULT_ERROR_INVALID_VALUE, end); ccs_expression_t *p_expr = NULL; size_t index = 0; while ((p_expr = (ccs_expression_t *)utarray_next( @@ -1490,5 +1573,7 @@ ccs_configuration_space_get_forbidden_clauses( } if (num_expressions_ret) *num_expressions_ret = num_forbidden_clauses; - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(configuration_space); + return err; } diff --git a/src/configuration_space_deserialize.h b/src/configuration_space_deserialize.h index 96b5faf9..68e80af7 100644 --- a/src/configuration_space_deserialize.h +++ b/src/configuration_space_deserialize.h @@ -146,19 +146,14 @@ _ccs_deserialize_bin_configuration_space( CCS_VALIDATE_ERR_GOTO( res, ccs_create_configuration_space( - data.name, configuration_space_ret), + data.name, data.num_parameters, data.parameters, + configuration_space_ret), end); CCS_VALIDATE_ERR_GOTO( res, ccs_configuration_space_set_rng( *configuration_space_ret, data.rng), end); - CCS_VALIDATE_ERR_GOTO( - res, - ccs_configuration_space_add_parameters( - *configuration_space_ret, data.num_parameters, - data.parameters, NULL), - err_configuration_space); for (size_t i = 0; i < data.num_conditions; i++) CCS_VALIDATE_ERR_GOTO( res, diff --git a/src/features_space.c b/src/features_space.c index 7bec62db..c9be3cda 100644 --- a/src/features_space.c +++ b/src/features_space.c @@ -80,59 +80,6 @@ static const UT_icd _parameter_wrapper_icd = { NULL, }; -#undef utarray_oom -#define utarray_oom() \ - { \ - CCS_RAISE_ERR_GOTO( \ - err, CCS_RESULT_ERROR_OUT_OF_MEMORY, arrays, \ - "Not enough memory to allocate array"); \ - } -ccs_result_t -ccs_create_features_space( - const char *name, - ccs_features_space_t *features_space_ret) -{ - ccs_result_t err; - CCS_CHECK_PTR(name); - CCS_CHECK_PTR(features_space_ret); - uintptr_t mem = (uintptr_t)calloc( - 1, sizeof(struct _ccs_features_space_s) + - sizeof(struct _ccs_features_space_data_s) + - strlen(name) + 1); - CCS_REFUTE(!mem, CCS_RESULT_ERROR_OUT_OF_MEMORY); - - ccs_features_space_t feat_space = (ccs_features_space_t)mem; - _ccs_object_init( - &(feat_space->obj), CCS_OBJECT_TYPE_FEATURES_SPACE, - (_ccs_object_ops_t *)&_features_space_ops); - feat_space->data = - (struct _ccs_features_space_data_s - *)(mem + sizeof(struct _ccs_features_space_s)); - feat_space->data->name = - (const char - *)(mem + sizeof(struct _ccs_features_space_s) + sizeof(struct _ccs_features_space_data_s)); - utarray_new(feat_space->data->parameters, &_parameter_wrapper_icd); - strcpy((char *)(feat_space->data->name), name); - *features_space_ret = feat_space; - return CCS_RESULT_SUCCESS; -arrays: - if (feat_space->data->parameters) - utarray_free(feat_space->data->parameters); - free((void *)mem); - return err; -} - -ccs_result_t -ccs_features_space_get_name( - ccs_features_space_t features_space, - const char **name_ret) -{ - CCS_CHECK_OBJ(features_space, CCS_OBJECT_TYPE_FEATURES_SPACE); - CCS_VALIDATE( - _ccs_context_get_name((ccs_context_t)features_space, name_ret)); - return CCS_RESULT_SUCCESS; -} - #undef utarray_oom #define utarray_oom() \ { \ @@ -147,12 +94,11 @@ ccs_features_space_get_name( err, CCS_RESULT_ERROR_OUT_OF_MEMORY, errorutarray, \ "Not enough memory to allocate hash"); \ } -ccs_result_t -ccs_features_space_add_parameter( +static ccs_result_t +_ccs_features_space_add_parameter( ccs_features_space_t features_space, ccs_parameter_t parameter) { - CCS_CHECK_OBJ(features_space, CCS_OBJECT_TYPE_FEATURES_SPACE); CCS_CHECK_OBJ(parameter, CCS_OBJECT_TYPE_PARAMETER); ccs_result_t err; const char *name; @@ -203,20 +149,88 @@ ccs_features_space_add_parameter( #undef utarray_oom #define utarray_oom() exit(-1) -ccs_result_t -ccs_features_space_add_parameters( +static ccs_result_t +_ccs_features_space_add_parameters( ccs_features_space_t features_space, size_t num_parameters, ccs_parameter_t *parameters) { - CCS_CHECK_OBJ(features_space, CCS_OBJECT_TYPE_FEATURES_SPACE); - CCS_CHECK_ARY(num_parameters, parameters); for (size_t i = 0; i < num_parameters; i++) - CCS_VALIDATE(ccs_features_space_add_parameter( + CCS_VALIDATE(_ccs_features_space_add_parameter( features_space, parameters[i])); return CCS_RESULT_SUCCESS; } +#undef utarray_oom +#define utarray_oom() \ + { \ + CCS_RAISE_ERR_GOTO( \ + err, CCS_RESULT_ERROR_OUT_OF_MEMORY, arrays, \ + "Not enough memory to allocate array"); \ + } + +ccs_result_t +ccs_create_features_space( + const char *name, + size_t num_parameters, + ccs_parameter_t *parameters, + ccs_features_space_t *features_space_ret) +{ + ccs_result_t err; + CCS_CHECK_PTR(name); + CCS_CHECK_PTR(features_space_ret); + CCS_REFUTE(!num_parameters, CCS_RESULT_ERROR_INVALID_VALUE); + CCS_CHECK_PTR(parameters); + + uintptr_t mem = (uintptr_t)calloc( + 1, sizeof(struct _ccs_features_space_s) + + sizeof(struct _ccs_features_space_data_s) + + strlen(name) + 1); + CCS_REFUTE(!mem, CCS_RESULT_ERROR_OUT_OF_MEMORY); + + ccs_features_space_t feat_space = (ccs_features_space_t)mem; + _ccs_object_init( + &(feat_space->obj), CCS_OBJECT_TYPE_FEATURES_SPACE, + (_ccs_object_ops_t *)&_features_space_ops); + feat_space->data = + (struct _ccs_features_space_data_s + *)(mem + sizeof(struct _ccs_features_space_s)); + feat_space->data->name = + (const char + *)(mem + sizeof(struct _ccs_features_space_s) + sizeof(struct _ccs_features_space_data_s)); + utarray_new(feat_space->data->parameters, &_parameter_wrapper_icd); + strcpy((char *)(feat_space->data->name), name); + *features_space_ret = feat_space; + CCS_VALIDATE_ERR_GOTO( + err, + _ccs_features_space_add_parameters( + feat_space, num_parameters, parameters), + errparams); + return CCS_RESULT_SUCCESS; +arrays: + if (feat_space->data->parameters) + utarray_free(feat_space->data->parameters); + free((void *)mem); + return err; +errparams: + _ccs_features_space_del(feat_space); + free((void *)mem); + return err; +} +#undef utarray_oom +#define utarray_oom() exit(-1) + +ccs_result_t +ccs_features_space_get_name( + ccs_features_space_t features_space, + const char **name_ret) +{ + CCS_CHECK_OBJ(features_space, CCS_OBJECT_TYPE_FEATURES_SPACE); + CCS_VALIDATE( + _ccs_context_get_name((ccs_context_t)features_space, name_ret)); + return CCS_RESULT_SUCCESS; +} + ccs_result_t ccs_features_space_get_num_parameters( ccs_features_space_t features_space, diff --git a/src/features_space_deserialize.h b/src/features_space_deserialize.h index 4cdcd1fe..141fed55 100644 --- a/src/features_space_deserialize.h +++ b/src/features_space_deserialize.h @@ -28,15 +28,12 @@ _ccs_deserialize_bin_features_space( _ccs_deserialize_bin_ccs_context_data( &data, version, buffer_size, buffer, &new_opts), end); - CCS_VALIDATE_ERR_GOTO( - res, ccs_create_features_space(data.name, features_space_ret), - end); CCS_VALIDATE_ERR_GOTO( res, - ccs_features_space_add_parameters( - *features_space_ret, data.num_parameters, - data.parameters), - err_features_space); + ccs_create_features_space( + data.name, data.num_parameters, data.parameters, + features_space_ret), + end); if (opts && opts->map_values && opts->handle_map) CCS_VALIDATE_ERR_GOTO( res, diff --git a/src/objective_space.c b/src/objective_space.c index 0355ea69..5ab5eedc 100644 --- a/src/objective_space.c +++ b/src/objective_space.c @@ -203,63 +203,6 @@ static const UT_icd _objectives_icd = { NULL, }; -#undef utarray_oom -#define utarray_oom() \ - { \ - CCS_RAISE_ERR_GOTO( \ - err, CCS_RESULT_ERROR_OUT_OF_MEMORY, arrays, \ - "Not enough memory to allocate array"); \ - } - -ccs_result_t -ccs_create_objective_space( - const char *name, - ccs_objective_space_t *objective_space_ret) -{ - CCS_CHECK_PTR(name); - CCS_CHECK_PTR(objective_space_ret); - - uintptr_t mem = (uintptr_t)calloc( - 1, sizeof(struct _ccs_objective_space_s) + - sizeof(struct _ccs_objective_space_data_s) + - strlen(name) + 1); - CCS_REFUTE(!mem, CCS_RESULT_ERROR_OUT_OF_MEMORY); - ccs_result_t err; - ccs_objective_space_t obj_space = (ccs_objective_space_t)mem; - _ccs_object_init( - &(obj_space->obj), CCS_OBJECT_TYPE_OBJECTIVE_SPACE, - (_ccs_object_ops_t *)&_objective_space_ops); - obj_space->data = - (struct _ccs_objective_space_data_s - *)(mem + sizeof(struct _ccs_objective_space_s)); - obj_space->data->name = - (const char - *)(mem + sizeof(struct _ccs_objective_space_s) + sizeof(struct _ccs_objective_space_data_s)); - utarray_new(obj_space->data->parameters, &_parameter_wrapper2_icd); - utarray_new(obj_space->data->objectives, &_objectives_icd); - strcpy((char *)(obj_space->data->name), name); - *objective_space_ret = obj_space; - return CCS_RESULT_SUCCESS; -arrays: - if (obj_space->data->parameters) - utarray_free(obj_space->data->parameters); - if (obj_space->data->objectives) - utarray_free(obj_space->data->objectives); - free((void *)mem); - return err; -} - -ccs_result_t -ccs_objective_space_get_name( - ccs_objective_space_t objective_space, - const char **name_ret) -{ - CCS_CHECK_OBJ(objective_space, CCS_OBJECT_TYPE_OBJECTIVE_SPACE); - CCS_VALIDATE(_ccs_context_get_name( - (ccs_context_t)objective_space, name_ret)); - return CCS_RESULT_SUCCESS; -} - #undef utarray_oom #define utarray_oom() \ { \ @@ -274,12 +217,11 @@ ccs_objective_space_get_name( err, CCS_RESULT_ERROR_OUT_OF_MEMORY, errorutarray, \ "Not enough memory to allocate hash"); \ } -ccs_result_t -ccs_objective_space_add_parameter( +static ccs_result_t +_ccs_objective_space_add_parameter( ccs_objective_space_t objective_space, ccs_parameter_t parameter) { - CCS_CHECK_OBJ(objective_space, CCS_OBJECT_TYPE_OBJECTIVE_SPACE); CCS_CHECK_OBJ(parameter, CCS_OBJECT_TYPE_PARAMETER); ccs_result_t err; const char *name; @@ -331,20 +273,90 @@ ccs_objective_space_add_parameter( #undef utarray_oom #define utarray_oom() exit(-1) -ccs_result_t -ccs_objective_space_add_parameters( +static ccs_result_t +_ccs_objective_space_add_parameters( ccs_objective_space_t objective_space, size_t num_parameters, ccs_parameter_t *parameters) { - CCS_CHECK_OBJ(objective_space, CCS_OBJECT_TYPE_OBJECTIVE_SPACE); - CCS_CHECK_ARY(num_parameters, parameters); for (size_t i = 0; i < num_parameters; i++) - CCS_VALIDATE(ccs_objective_space_add_parameter( + CCS_VALIDATE(_ccs_objective_space_add_parameter( objective_space, parameters[i])); return CCS_RESULT_SUCCESS; } +#undef utarray_oom +#define utarray_oom() \ + { \ + CCS_RAISE_ERR_GOTO( \ + err, CCS_RESULT_ERROR_OUT_OF_MEMORY, arrays, \ + "Not enough memory to allocate array"); \ + } + +ccs_result_t +ccs_create_objective_space( + const char *name, + size_t num_parameters, + ccs_parameter_t *parameters, + ccs_objective_space_t *objective_space_ret) +{ + CCS_CHECK_PTR(name); + CCS_CHECK_PTR(objective_space_ret); + CCS_REFUTE(!num_parameters, CCS_RESULT_ERROR_INVALID_VALUE); + CCS_CHECK_PTR(parameters); + + uintptr_t mem = (uintptr_t)calloc( + 1, sizeof(struct _ccs_objective_space_s) + + sizeof(struct _ccs_objective_space_data_s) + + strlen(name) + 1); + CCS_REFUTE(!mem, CCS_RESULT_ERROR_OUT_OF_MEMORY); + ccs_result_t err; + ccs_objective_space_t obj_space = (ccs_objective_space_t)mem; + _ccs_object_init( + &(obj_space->obj), CCS_OBJECT_TYPE_OBJECTIVE_SPACE, + (_ccs_object_ops_t *)&_objective_space_ops); + obj_space->data = + (struct _ccs_objective_space_data_s + *)(mem + sizeof(struct _ccs_objective_space_s)); + obj_space->data->name = + (const char + *)(mem + sizeof(struct _ccs_objective_space_s) + sizeof(struct _ccs_objective_space_data_s)); + utarray_new(obj_space->data->parameters, &_parameter_wrapper2_icd); + utarray_new(obj_space->data->objectives, &_objectives_icd); + strcpy((char *)(obj_space->data->name), name); + *objective_space_ret = obj_space; + CCS_VALIDATE_ERR_GOTO( + err, + _ccs_objective_space_add_parameters( + obj_space, num_parameters, parameters), + errparams); + return CCS_RESULT_SUCCESS; +arrays: + if (obj_space->data->parameters) + utarray_free(obj_space->data->parameters); + if (obj_space->data->objectives) + utarray_free(obj_space->data->objectives); + free((void *)mem); + return err; +errparams: + _ccs_objective_space_del(obj_space); + free((void *)mem); + return err; +} +#undef utarray_oom +#define utarray_oom() exit(-1) + +ccs_result_t +ccs_objective_space_get_name( + ccs_objective_space_t objective_space, + const char **name_ret) +{ + CCS_CHECK_OBJ(objective_space, CCS_OBJECT_TYPE_OBJECTIVE_SPACE); + CCS_VALIDATE(_ccs_context_get_name( + (ccs_context_t)objective_space, name_ret)); + return CCS_RESULT_SUCCESS; +} + ccs_result_t ccs_objective_space_get_num_parameters( ccs_objective_space_t objective_space, @@ -487,8 +499,9 @@ ccs_objective_space_validate_value( #undef utarray_oom #define utarray_oom() \ { \ - CCS_RAISE( \ - CCS_RESULT_ERROR_OUT_OF_MEMORY, \ + ccs_release_object(expression); \ + CCS_RAISE_ERR_GOTO( \ + err, CCS_RESULT_ERROR_OUT_OF_MEMORY, end, \ "Out of memory to allocate array"); \ } ccs_result_t @@ -501,13 +514,27 @@ ccs_objective_space_add_objective( CCS_VALIDATE(ccs_expression_check_context( expression, (ccs_context_t)objective_space)); CCS_VALIDATE(ccs_retain_object(expression)); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_WRLOCK(objective_space); _ccs_objective_t objective; objective.expression = expression; objective.type = type; utarray_push_back(objective_space->data->objectives, &objective); - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(objective_space); + return err; } +#undef utarray_oom +#define utarray_oom() exit(-1) +#undef utarray_oom +#define utarray_oom() \ + { \ + ccs_release_object(expressions[i]); \ + CCS_RAISE_ERR_GOTO( \ + err, CCS_RESULT_ERROR_OUT_OF_MEMORY, end, \ + "Out of memory to allocate array"); \ + } ccs_result_t ccs_objective_space_add_objectives( ccs_objective_space_t objective_space, @@ -518,17 +545,25 @@ ccs_objective_space_add_objectives( CCS_CHECK_OBJ(objective_space, CCS_OBJECT_TYPE_OBJECTIVE_SPACE); CCS_CHECK_ARY(num_objectives, expressions); CCS_CHECK_ARY(num_objectives, types); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_WRLOCK(objective_space); for (size_t i = 0; i < num_objectives; i++) { - CCS_VALIDATE(ccs_expression_check_context( - expressions[i], (ccs_context_t)objective_space)); - CCS_VALIDATE(ccs_retain_object(expressions[i])); + CCS_VALIDATE_ERR_GOTO( + err, + ccs_expression_check_context( + expressions[i], (ccs_context_t)objective_space), + end); + CCS_VALIDATE_ERR_GOTO( + err, ccs_retain_object(expressions[i]), end); _ccs_objective_t objective; objective.expression = expressions[i]; objective.type = types[i]; utarray_push_back( objective_space->data->objectives, &objective); } - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(objective_space); + return err; } #undef utarray_oom #define utarray_oom() exit(-1) @@ -543,12 +578,16 @@ ccs_objective_space_get_objective( CCS_CHECK_OBJ(objective_space, CCS_OBJECT_TYPE_OBJECTIVE_SPACE); CCS_CHECK_PTR(expression_ret); CCS_CHECK_PTR(type_ret); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(objective_space); _ccs_objective_t *p_obj = (_ccs_objective_t *)utarray_eltptr( objective_space->data->objectives, (unsigned int)index); - CCS_REFUTE(!p_obj, CCS_RESULT_ERROR_OUT_OF_BOUNDS); + CCS_REFUTE_ERR_GOTO(err, !p_obj, CCS_RESULT_ERROR_OUT_OF_BOUNDS, end); *expression_ret = p_obj->expression; *type_ret = p_obj->type; - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(objective_space); + return err; } ccs_result_t @@ -565,11 +604,14 @@ ccs_objective_space_get_objectives( CCS_REFUTE( !expressions && !num_objectives_ret, CCS_RESULT_ERROR_INVALID_VALUE); + ccs_result_t err = CCS_RESULT_SUCCESS; + CCS_OBJ_RDLOCK(objective_space); UT_array *array = objective_space->data->objectives; size_t size = utarray_len(array); if (expressions) { - CCS_REFUTE( - num_objectives < size, CCS_RESULT_ERROR_INVALID_VALUE); + CCS_REFUTE_ERR_GOTO( + err, num_objectives < size, + CCS_RESULT_ERROR_INVALID_VALUE, end); _ccs_objective_t *p_obj = NULL; size_t index = 0; while ((p_obj = (_ccs_objective_t *)utarray_next( @@ -585,5 +627,7 @@ ccs_objective_space_get_objectives( } if (num_objectives_ret) *num_objectives_ret = size; - return CCS_RESULT_SUCCESS; +end: + CCS_OBJ_UNLOCK(objective_space); + return err; } diff --git a/src/objective_space_deserialize.h b/src/objective_space_deserialize.h index 3baec984..0a85748c 100644 --- a/src/objective_space_deserialize.h +++ b/src/objective_space_deserialize.h @@ -87,15 +87,12 @@ _ccs_deserialize_bin_objective_space( _ccs_deserialize_bin_ccs_objective_space_data( &data, version, buffer_size, buffer, &new_opts), end); - CCS_VALIDATE_ERR_GOTO( - res, ccs_create_objective_space(data.name, objective_space_ret), - end); CCS_VALIDATE_ERR_GOTO( res, - ccs_objective_space_add_parameters( - *objective_space_ret, data.num_parameters, - data.parameters), - err_objective_space); + ccs_create_objective_space( + data.name, data.num_parameters, data.parameters, + objective_space_ret), + end); CCS_VALIDATE_ERR_GOTO( res, ccs_objective_space_add_objectives( diff --git a/src/parameter_string.c b/src/parameter_string.c index b2da1c79..47a98ec4 100644 --- a/src/parameter_string.c +++ b/src/parameter_string.c @@ -8,7 +8,7 @@ struct _ccs_parameter_string_data_s { _ccs_parameter_common_data_t common_data; _ccs_hash_datum_t *stored_values; #if CCS_THREAD_SAFE - pthread_mutex_t mutex; + pthread_mutex_t mutex; #endif }; typedef struct _ccs_parameter_string_data_s _ccs_parameter_string_data_t; @@ -266,8 +266,8 @@ ccs_create_string_parameter(const char *name, ccs_parameter_t *parameter_ret) #if CCS_THREAD_SAFE parameter_data->mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER; #endif - parameter->data = (_ccs_parameter_data_t *)parameter_data; - *parameter_ret = parameter; + parameter->data = (_ccs_parameter_data_t *)parameter_data; + *parameter_ret = parameter; return CCS_RESULT_SUCCESS; } diff --git a/tests/test_condition.c b/tests/test_condition.c index df934e0d..b51ae9ab 100644 --- a/tests/test_condition.c +++ b/tests/test_condition.c @@ -20,6 +20,7 @@ void test_simple() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_configuration_space_t space; ccs_expression_t expression; ccs_configuration_t configuration; @@ -27,13 +28,9 @@ test_simple() ccs_configuration_t configurations[100]; ccs_result_t err; - parameter1 = create_numerical("param1"); - parameter2 = create_numerical("param2"); - err = ccs_create_configuration_space("space", &space); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(space, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(space, parameter2, NULL); + parameters[0] = parameter1 = create_numerical("param1"); + parameters[1] = parameter2 = create_numerical("param2"); + err = ccs_create_configuration_space("space", 2, parameters, &space); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_binary_expression( @@ -116,11 +113,7 @@ test_transitive() parameters[1] = create_numerical("param2"); parameters[2] = create_numerical("param3"); - err = ccs_create_configuration_space("space", &space); - assert(err == CCS_RESULT_SUCCESS); - - err = ccs_configuration_space_add_parameters( - space, 3, parameters, NULL); + err = ccs_create_configuration_space("space", 3, parameters, &space); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_binary_expression( diff --git a/tests/test_configuration_space.c b/tests/test_configuration_space.c index d7ca39d9..39046258 100644 --- a/tests/test_configuration_space.c +++ b/tests/test_configuration_space.c @@ -20,36 +20,6 @@ create_dummy_parameter(const char *name) return parameter; } -void -test_create() -{ - ccs_configuration_space_t configuration_space; - ccs_result_t err; - ccs_object_type_t type; - const char *name; - size_t sz; - - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); - - err = ccs_object_get_type(configuration_space, &type); - assert(err == CCS_RESULT_SUCCESS); - assert(type == CCS_OBJECT_TYPE_CONFIGURATION_SPACE); - - err = ccs_configuration_space_get_name(configuration_space, &name); - assert(err == CCS_RESULT_SUCCESS); - assert(strcmp(name, "my_config_space") == 0); - - err = ccs_configuration_space_get_num_parameters( - configuration_space, &sz); - assert(err == CCS_RESULT_SUCCESS); - assert(sz == 0); - - err = ccs_release_object(configuration_space); - assert(err == CCS_RESULT_SUCCESS); -} - void check_configuration( ccs_configuration_space_t configuration_space, @@ -120,63 +90,45 @@ check_configuration( } void -test_add() +test_create() { ccs_parameter_t parameters[3]; + ccs_parameter_t parameter3; ccs_configuration_space_t configuration_space; ccs_result_t err; - - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); + ccs_object_type_t type; + const char *name; parameters[0] = create_dummy_parameter("param1"); parameters[1] = create_dummy_parameter("param2"); - parameters[2] = create_dummy_parameter("param3"); + parameter3 = create_dummy_parameter("param3"); + parameters[2] = parameters[0]; - err = ccs_configuration_space_add_parameter( - configuration_space, parameters[0], NULL); - assert(err == CCS_RESULT_SUCCESS); + err = ccs_create_configuration_space( + "my_config_space", 3, NULL, &configuration_space); + assert(err == CCS_RESULT_ERROR_INVALID_VALUE); - err = ccs_configuration_space_add_parameter( - configuration_space, parameters[0], NULL); - assert(err == CCS_RESULT_ERROR_INVALID_PARAMETER); + err = ccs_create_configuration_space( + "my_config_space", 0, parameters, &configuration_space); + assert(err == CCS_RESULT_ERROR_INVALID_VALUE); - err = ccs_configuration_space_add_parameter( - configuration_space, parameters[1], NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter( - configuration_space, parameters[2], NULL); - assert(err == CCS_RESULT_SUCCESS); + err = ccs_create_configuration_space( + "my_config_space", 3, parameters, &configuration_space); + assert(err == CCS_RESULT_ERROR_INVALID_PARAMETER); - check_configuration(configuration_space, 3, parameters); + parameters[2] = parameter3; - for (size_t i = 0; i < 3; i++) { - err = ccs_release_object(parameters[i]); - assert(err == CCS_RESULT_SUCCESS); - } - err = ccs_release_object(configuration_space); + err = ccs_create_configuration_space( + "my_config_space", 3, parameters, &configuration_space); assert(err == CCS_RESULT_SUCCESS); -} -void -test_add_list() -{ - ccs_parameter_t parameters[3]; - ccs_configuration_space_t configuration_space; - ccs_result_t err; - - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); + err = ccs_object_get_type(configuration_space, &type); assert(err == CCS_RESULT_SUCCESS); + assert(type == CCS_OBJECT_TYPE_CONFIGURATION_SPACE); - parameters[0] = create_dummy_parameter("param1"); - parameters[1] = create_dummy_parameter("param2"); - parameters[2] = create_dummy_parameter("param3"); - - err = ccs_configuration_space_add_parameters( - configuration_space, 3, parameters, NULL); + err = ccs_configuration_space_get_name(configuration_space, &name); assert(err == CCS_RESULT_SUCCESS); + assert(strcmp(name, "my_config_space") == 0); check_configuration(configuration_space, 3, parameters); @@ -198,10 +150,6 @@ test_sample() ccs_result_t err; ccs_bool_t check; - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_dummy_parameter("param1"); parameters[1] = create_dummy_parameter("param2"); parameters[2] = create_dummy_parameter("param3"); @@ -210,8 +158,8 @@ test_sample() CCSI(0), parameters + 3); assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameters( - configuration_space, 4, parameters, NULL); + err = ccs_create_configuration_space( + "my_config_space", 4, parameters, &configuration_space); assert(err == CCS_RESULT_SUCCESS); err = ccs_configuration_space_sample( @@ -258,16 +206,12 @@ test_set_distribution() ccs_result_t err; ccs_bool_t check; - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_dummy_parameter("param1"); parameters[1] = create_dummy_parameter("param2"); parameters[2] = create_dummy_parameter("param3"); - err = ccs_configuration_space_add_parameters( - configuration_space, 3, parameters, NULL); + err = ccs_create_configuration_space( + "my_config_space", 3, parameters, &configuration_space); assert(err == CCS_RESULT_SUCCESS); check_configuration(configuration_space, 3, parameters); @@ -400,16 +344,14 @@ test_configuration_deserialize() ccs_result_t err; int cmp; - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_numerical("param1"); parameters[1] = create_numerical("param2"); parameters[2] = create_numerical("param3"); - err = ccs_configuration_space_add_parameters( - configuration_space, 3, parameters, NULL); + + err = ccs_create_configuration_space( + "my_config_space", 3, parameters, &configuration_space); assert(err == CCS_RESULT_SUCCESS); + err = ccs_configuration_space_sample( configuration_space, &configuration_ref); assert(err == CCS_RESULT_SUCCESS); @@ -486,15 +428,12 @@ test_deserialize() ccs_datum_t d; ccs_result_t err; - err = ccs_create_configuration_space("my_config_space", &space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_numerical("param1"); parameters[1] = create_numerical("param2"); parameters[2] = create_numerical("param3"); - err = ccs_configuration_space_add_parameters( - space, 3, parameters, NULL); + err = ccs_create_configuration_space( + "my_config_space", 3, parameters, &space); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_uniform_distribution( @@ -641,8 +580,6 @@ main() { ccs_init(); test_create(); - test_add(); - test_add_list(); test_sample(); test_set_distribution(); test_deserialize(); diff --git a/tests/test_expression.c b/tests/test_expression.c index b275c901..9ffb27ff 100644 --- a/tests/test_expression.c +++ b/tests/test_expression.c @@ -164,15 +164,11 @@ test_equal_numerical() ccs_datum_t values[2]; ccs_result_t err; - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_dummy_numerical("param1"); parameters[1] = create_dummy_numerical("param2"); - err = ccs_configuration_space_add_parameters( - configuration_space, 2, parameters, NULL); + err = ccs_create_configuration_space( + "my_config_space", 2, parameters, &configuration_space); assert(err == CCS_RESULT_SUCCESS); nodes[0] = ccs_object(parameters[0]); @@ -223,13 +219,10 @@ test_equal_categorical() ccs_datum_t values[2]; ccs_result_t err; - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); parameters[0] = create_dummy_categorical("param1"); parameters[1] = create_dummy_categorical("param2"); - err = ccs_configuration_space_add_parameters( - configuration_space, 2, parameters, NULL); + err = ccs_create_configuration_space( + "my_config_space", 2, parameters, &configuration_space); assert(err == CCS_RESULT_SUCCESS); nodes[0] = ccs_object(parameters[0]); @@ -266,13 +259,10 @@ test_equal_ordinal() ccs_datum_t values[2]; ccs_result_t err; - err = ccs_create_configuration_space( - "my_config_space", &configuration_space); - assert(err == CCS_RESULT_SUCCESS); parameters[0] = create_dummy_ordinal("param1"); parameters[1] = create_dummy_ordinal("param2"); - err = ccs_configuration_space_add_parameters( - configuration_space, 2, parameters, NULL); + err = ccs_create_configuration_space( + "my_config_space", 2, parameters, &configuration_space); assert(err == CCS_RESULT_SUCCESS); nodes[0] = ccs_object(parameters[0]); @@ -900,18 +890,17 @@ test_check_context() { ccs_expression_t expression1, expression2; ccs_parameter_t parameter1, parameter2, parameter3; + ccs_parameter_t parameters[2]; ccs_configuration_space_t space; ccs_result_t err; - parameter1 = create_dummy_categorical("param1"); - parameter2 = create_dummy_numerical("param2"); - parameter3 = create_dummy_ordinal("param3"); + parameter1 = create_dummy_categorical("param1"); + parameter2 = create_dummy_numerical("param2"); + parameter3 = create_dummy_ordinal("param3"); + parameters[0] = parameter1; + parameters[1] = parameter2; - err = ccs_create_configuration_space("space", &space); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(space, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(space, parameter2, NULL); + err = ccs_create_configuration_space("space", 2, parameters, &space); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_binary_expression( diff --git a/tests/test_features_space.c b/tests/test_features_space.c index d5a930bc..3b42c88a 100644 --- a/tests/test_features_space.c +++ b/tests/test_features_space.c @@ -20,34 +20,6 @@ create_dummy_parameter(const char *name) return parameter; } -void -test_create() -{ - ccs_features_space_t features_space; - ccs_result_t err; - ccs_object_type_t type; - const char *name; - size_t sz; - - err = ccs_create_features_space("my_features_space", &features_space); - assert(err == CCS_RESULT_SUCCESS); - - err = ccs_object_get_type(features_space, &type); - assert(err == CCS_RESULT_SUCCESS); - assert(type == CCS_OBJECT_TYPE_FEATURES_SPACE); - - err = ccs_features_space_get_name(features_space, &name); - assert(err == CCS_RESULT_SUCCESS); - assert(strcmp(name, "my_features_space") == 0); - - err = ccs_features_space_get_num_parameters(features_space, &sz); - assert(err == CCS_RESULT_SUCCESS); - assert(sz == 0); - - err = ccs_release_object(features_space); - assert(err == CCS_RESULT_SUCCESS); -} - void check_features( ccs_features_space_t features_space, @@ -97,56 +69,45 @@ check_features( } void -test_add() +test_create() { ccs_parameter_t parameters[3]; + ccs_parameter_t parameter3; ccs_features_space_t features_space; ccs_result_t err; - - err = ccs_create_features_space("my_features_space", &features_space); - assert(err == CCS_RESULT_SUCCESS); + ccs_object_type_t type; + const char *name; parameters[0] = create_dummy_parameter("param1"); parameters[1] = create_dummy_parameter("param2"); - parameters[2] = create_dummy_parameter("param3"); + parameter3 = create_dummy_parameter("param3"); + parameters[2] = parameters[0]; - err = ccs_features_space_add_parameter(features_space, parameters[0]); - assert(err == CCS_RESULT_SUCCESS); + err = ccs_create_features_space( + "my_features_space", 3, NULL, &features_space); + assert(err == CCS_RESULT_ERROR_INVALID_VALUE); - err = ccs_features_space_add_parameter(features_space, parameters[0]); - assert(err == CCS_RESULT_ERROR_INVALID_PARAMETER); + err = ccs_create_features_space( + "my_features_space", 0, parameters, &features_space); + assert(err == CCS_RESULT_ERROR_INVALID_VALUE); - err = ccs_features_space_add_parameter(features_space, parameters[1]); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_features_space_add_parameter(features_space, parameters[2]); - assert(err == CCS_RESULT_SUCCESS); + err = ccs_create_features_space( + "my_features_space", 3, parameters, &features_space); + assert(err == CCS_RESULT_ERROR_INVALID_PARAMETER); - check_features(features_space, 3, parameters); + parameters[2] = parameter3; - for (size_t i = 0; i < 3; i++) { - err = ccs_release_object(parameters[i]); - assert(err == CCS_RESULT_SUCCESS); - } - err = ccs_release_object(features_space); + err = ccs_create_features_space( + "my_features_space", 3, parameters, &features_space); assert(err == CCS_RESULT_SUCCESS); -} - -void -test_add_list() -{ - ccs_parameter_t parameters[3]; - ccs_features_space_t features_space; - ccs_result_t err; - err = ccs_create_features_space("my_config_space", &features_space); + err = ccs_object_get_type(features_space, &type); assert(err == CCS_RESULT_SUCCESS); + assert(type == CCS_OBJECT_TYPE_FEATURES_SPACE); - parameters[0] = create_dummy_parameter("param1"); - parameters[1] = create_dummy_parameter("param2"); - parameters[2] = create_dummy_parameter("param3"); - - err = ccs_features_space_add_parameters(features_space, 3, parameters); + err = ccs_features_space_get_name(features_space, &name); assert(err == CCS_RESULT_SUCCESS); + assert(strcmp(name, "my_features_space") == 0); check_features(features_space, 3, parameters); @@ -173,14 +134,12 @@ test_features() int cmp; ccs_bool_t check; - err = ccs_create_features_space("my_config_space", &features_space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_dummy_parameter("param1"); parameters[1] = create_dummy_parameter("param2"); parameters[2] = create_dummy_parameter("param3"); - err = ccs_features_space_add_parameters(features_space, 3, parameters); + err = ccs_create_features_space( + "my_feature_space", 3, parameters, &features_space); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_features(features_space, 3, values, &features1); @@ -269,14 +228,12 @@ test_deserialize() size_t buff_size; ccs_datum_t d; - err = ccs_create_features_space("my_config_space", &features_space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_dummy_parameter("param1"); parameters[1] = create_dummy_parameter("param2"); parameters[2] = create_dummy_parameter("param3"); - err = ccs_features_space_add_parameters(features_space, 3, parameters); + err = ccs_create_features_space( + "my_config_space", 3, parameters, &features_space); assert(err == CCS_RESULT_SUCCESS); check_features(features_space, 3, parameters); @@ -369,14 +326,14 @@ test_features_deserialize() ccs_result_t err; int cmp; - err = ccs_create_features_space("my_config_space", &features_space); - assert(err == CCS_RESULT_SUCCESS); - parameters[0] = create_dummy_parameter("param1"); parameters[1] = create_dummy_parameter("param2"); parameters[2] = create_dummy_parameter("param3"); - err = ccs_features_space_add_parameters(features_space, 3, parameters); + + err = ccs_create_features_space( + "my_config_space", 3, parameters, &features_space); assert(err == CCS_RESULT_SUCCESS); + err = ccs_create_features(features_space, 3, values, &features_ref); assert(err == CCS_RESULT_SUCCESS); @@ -439,8 +396,6 @@ main() { ccs_init(); test_create(); - test_add(); - test_add_list(); test_features(); test_deserialize(); test_features_deserialize(); diff --git a/tests/test_forbidden.c b/tests/test_forbidden.c index 20141463..319f6b1f 100644 --- a/tests/test_forbidden.c +++ b/tests/test_forbidden.c @@ -20,6 +20,7 @@ void test_simple() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_configuration_space_t space; ccs_expression_t expression; ccs_configuration_t configuration; @@ -27,13 +28,9 @@ test_simple() ccs_configuration_t configurations[100]; ccs_result_t err; - parameter1 = create_numerical("param1"); - parameter2 = create_numerical("param2"); - err = ccs_create_configuration_space("space", &space); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(space, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(space, parameter2, NULL); + parameters[0] = parameter1 = create_numerical("param1"); + parameters[1] = parameter2 = create_numerical("param2"); + err = ccs_create_configuration_space("space", 2, parameters, &space); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_binary_expression( @@ -113,11 +110,7 @@ test_combined() parameters[1] = create_numerical("param2"); parameters[2] = create_numerical("param3"); - err = ccs_create_configuration_space("space", &space); - assert(err == CCS_RESULT_SUCCESS); - - err = ccs_configuration_space_add_parameters( - space, 3, parameters, NULL); + err = ccs_create_configuration_space("space", 3, parameters, &space); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_binary_expression( diff --git a/tests/test_random_features_tuner.c b/tests/test_random_features_tuner.c index 5920bc57..93e3d110 100644 --- a/tests/test_random_features_tuner.c +++ b/tests/test_random_features_tuner.c @@ -19,6 +19,7 @@ void test() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_parameter_t feature; ccs_configuration_space_t cspace; @@ -34,23 +35,17 @@ test() size_t buff_size; ccs_map_t map; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); parameter3 = create_numerical("z", -CCS_INFINITY, CCS_INFINITY); err = ccs_create_variable(parameter3, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE); @@ -60,9 +55,7 @@ test() "red knob", 2, knobs_values, 0, &feature); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_features_space("knobs", &fspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_features_space_add_parameter(fspace, feature); + err = ccs_create_features_space("knobs", 1, &feature, &fspace); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_features(fspace, 1, knobs_values, &features_on); assert(err == CCS_RESULT_SUCCESS); @@ -247,6 +240,7 @@ void test_evaluation_deserialize() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_parameter_t feature; ccs_configuration_space_t cspace; @@ -264,14 +258,10 @@ test_evaluation_deserialize() ccs_map_t map; int cmp; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); err = ccs_configuration_space_sample(cspace, &configuration); assert(err == CCS_RESULT_SUCCESS); @@ -284,14 +274,10 @@ test_evaluation_deserialize() "red knob", 2, knobs_values, 0, &feature); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_features_space("knobs", &fspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_features_space_add_parameter(fspace, feature); + err = ccs_create_features_space("knobs", 1, &feature, &fspace); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_features(fspace, 1, knobs_values, &features_on); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE); diff --git a/tests/test_random_tree_tuner.c b/tests/test_random_tree_tuner.c index 12af2da6..1fc30abc 100644 --- a/tests/test_random_tree_tuner.c +++ b/tests/test_random_tree_tuner.c @@ -52,9 +52,7 @@ create_tree_tuning_problem( err = ccs_create_variable(parameter, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("ospace", ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(*ospace, parameter); + err = ccs_create_objective_space("ospace", 1, ¶meter, ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( *ospace, expression, CCS_OBJECTIVE_TYPE_MAXIMIZE); diff --git a/tests/test_random_tuner.c b/tests/test_random_tuner.c index 54b569ee..e0ad460d 100644 --- a/tests/test_random_tuner.c +++ b/tests/test_random_tuner.c @@ -19,6 +19,7 @@ void test() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_configuration_space_t cspace; ccs_objective_space_t ospace; @@ -30,23 +31,17 @@ test() size_t buff_size; ccs_map_t map; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); parameter3 = create_numerical("z", -CCS_INFINITY, CCS_INFINITY); err = ccs_create_variable(parameter3, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE); @@ -163,6 +158,7 @@ void test_evaluation_deserialize() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_configuration_space_t cspace; ccs_objective_space_t ospace; @@ -176,14 +172,10 @@ test_evaluation_deserialize() ccs_map_t map; int cmp; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); err = ccs_configuration_space_sample(cspace, &configuration); assert(err == CCS_RESULT_SUCCESS); @@ -192,9 +184,7 @@ test_evaluation_deserialize() err = ccs_create_variable(parameter3, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE); diff --git a/tests/test_user_defined_features_tuner.c b/tests/test_user_defined_features_tuner.c index 1d4df416..63fb2b0b 100644 --- a/tests/test_user_defined_features_tuner.c +++ b/tests/test_user_defined_features_tuner.c @@ -159,6 +159,7 @@ void test() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_parameter_t feature; ccs_configuration_space_t cspace; @@ -175,23 +176,17 @@ test() size_t buff_size; ccs_map_t map; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); parameter3 = create_numerical("z", -CCS_INFINITY, CCS_INFINITY); err = ccs_create_variable(parameter3, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE); @@ -201,9 +196,7 @@ test() "red knob", 2, knobs_values, 0, &feature); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_features_space("knobs", &fspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_features_space_add_parameter(fspace, feature); + err = ccs_create_features_space("knobs", 1, &feature, &fspace); assert(err == CCS_RESULT_SUCCESS); err = ccs_create_features(fspace, 1, knobs_values, &features_on); assert(err == CCS_RESULT_SUCCESS); diff --git a/tests/test_user_defined_tree_tuner.c b/tests/test_user_defined_tree_tuner.c index 2c4d6c72..c8930bc6 100644 --- a/tests/test_user_defined_tree_tuner.c +++ b/tests/test_user_defined_tree_tuner.c @@ -52,9 +52,7 @@ create_tree_tuning_problem( err = ccs_create_variable(parameter, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("ospace", ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(*ospace, parameter); + err = ccs_create_objective_space("ospace", 1, ¶meter, ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( *ospace, expression, CCS_OBJECTIVE_TYPE_MAXIMIZE); diff --git a/tests/test_user_defined_tuner.c b/tests/test_user_defined_tuner.c index 8693c9fd..ebf85b7e 100644 --- a/tests/test_user_defined_tuner.c +++ b/tests/test_user_defined_tuner.c @@ -147,6 +147,7 @@ void test() { ccs_parameter_t parameter1, parameter2; + ccs_parameter_t parameters[2]; ccs_parameter_t parameter3; ccs_configuration_space_t cspace; ccs_objective_space_t ospace; @@ -159,23 +160,17 @@ test() size_t buff_size; ccs_map_t map; - parameter1 = create_numerical("x", -5.0, 5.0); - parameter2 = create_numerical("y", -5.0, 5.0); + parameters[0] = parameter1 = create_numerical("x", -5.0, 5.0); + parameters[1] = parameter2 = create_numerical("y", -5.0, 5.0); - err = ccs_create_configuration_space("2dplane", &cspace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter1, NULL); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_configuration_space_add_parameter(cspace, parameter2, NULL); + err = ccs_create_configuration_space("2dplane", 2, parameters, &cspace); assert(err == CCS_RESULT_SUCCESS); parameter3 = create_numerical("z", -CCS_INFINITY, CCS_INFINITY); err = ccs_create_variable(parameter3, &expression); assert(err == CCS_RESULT_SUCCESS); - err = ccs_create_objective_space("height", &ospace); - assert(err == CCS_RESULT_SUCCESS); - err = ccs_objective_space_add_parameter(ospace, parameter3); + err = ccs_create_objective_space("height", 1, ¶meter3, &ospace); assert(err == CCS_RESULT_SUCCESS); err = ccs_objective_space_add_objective( ospace, expression, CCS_OBJECTIVE_TYPE_MINIMIZE);