From 0a4b105c3e51653d34d239a8ac0149efd46d10b8 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Mon, 18 Dec 2023 22:54:05 -0600 Subject: [PATCH 001/120] direct implementation of run, start, wait, await, example, forceStop --- .../cli/NBCLIScenarioPreprocessorTest.java | 3 + .../engine/cli/TestNBCLIOptions.java | 66 +++++++++---------- .../engine/cmdstream/BasicScriptBuffer.java | 5 -- .../nosqlbench/engine/cmdstream/CmdType.java | 10 +-- .../core/lifecycle/commands/CMD_await.java | 45 +++++++++++++ .../core/lifecycle/commands/CMD_example.java | 45 +++++++++++++ .../lifecycle/commands/CMD_forceStop.java | 46 +++++++++++++ .../core/lifecycle/commands/CMD_run.java | 43 ++++++++++++ .../core/lifecycle/commands/CMD_start.java | 45 +++++++++++++ .../core/lifecycle/commands/CMD_wait.java | 66 +++++++++++++++++++ .../core/lifecycle/commands/INFO_await.java | 29 ++++++++ .../core/lifecycle/commands/INFO_example.java | 29 ++++++++ .../lifecycle/commands/INFO_forceStop.java | 29 ++++++++ .../core/lifecycle/commands/INFO_run.java | 29 ++++++++ .../core/lifecycle/commands/INFO_start.java | 29 ++++++++ .../core/lifecycle/commands/INFO_wait.java | 29 ++++++++ .../session/NBScriptCommandResolver.java | 2 +- .../core/lifecycle/session/CmdParserTest.java | 41 ++++++------ mvn-defaults/pom.xml | 4 +- 19 files changed, 530 insertions(+), 65 deletions(-) create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_await.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_example.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_forceStop.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_run.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_start.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_wait.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_await.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_forceStop.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_run.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_start.java create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_wait.java diff --git a/engine-cli/src/test/java/io/nosqlbench/engine/cli/NBCLIScenarioPreprocessorTest.java b/engine-cli/src/test/java/io/nosqlbench/engine/cli/NBCLIScenarioPreprocessorTest.java index d8c82867b..11cd593e1 100644 --- a/engine-cli/src/test/java/io/nosqlbench/engine/cli/NBCLIScenarioPreprocessorTest.java +++ b/engine-cli/src/test/java/io/nosqlbench/engine/cli/NBCLIScenarioPreprocessorTest.java @@ -105,6 +105,7 @@ public class NBCLIScenarioPreprocessorTest { List cmds = opts.getCommands(); assertThat(cmds.size()).isEqualTo(1); assertThat(cmds.get(0).getArgMap()).isEqualTo(Map.of( + "_impl","run", "alias", "with_template", "container", "template_test", "cycles", "20", @@ -122,6 +123,7 @@ public class NBCLIScenarioPreprocessorTest { List cmds = opts.getCommands(); assertThat(cmds.size()).isEqualTo(1); assertThat(cmds.get(0).getArgMap()).isEqualTo(Map.of( + "_impl", "run", "alias", "schema", "container", "schema_only", "cycles-test", "20", @@ -176,6 +178,7 @@ public class NBCLIScenarioPreprocessorTest { List cmds = opts.getCommands(); assertThat(cmds.size()).isEqualTo(1); assertThat(cmds.get(0).getArgMap()).isEqualTo(Map.of( + "_impl","run", "alias", "schema", "container", "schema_only", "cycles-test", "20", diff --git a/engine-cli/src/test/java/io/nosqlbench/engine/cli/TestNBCLIOptions.java b/engine-cli/src/test/java/io/nosqlbench/engine/cli/TestNBCLIOptions.java index 0aa51f465..ab37ede4f 100644 --- a/engine-cli/src/test/java/io/nosqlbench/engine/cli/TestNBCLIOptions.java +++ b/engine-cli/src/test/java/io/nosqlbench/engine/cli/TestNBCLIOptions.java @@ -137,23 +137,23 @@ public class TestNBCLIOptions { .isThrownBy(() -> new NBCLIOptions(new String[]{"script"})); } - @Test - public void shouldRecognizeStartActivityCmd() { - NBCLIOptions opts = new NBCLIOptions(new String[]{ "start", "driver=woot" }); - List cmds = opts.getCommands(); - assertThat(cmds).hasSize(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.start); - - } - - @Test - public void shouldRecognizeRunActivityCmd() { - NBCLIOptions opts = new NBCLIOptions(new String[]{ "run", "driver=runwoot" }); - List cmds = opts.getCommands(); - assertThat(cmds).hasSize(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.run); - - } +// @Test +// public void shouldRecognizeStartActivityCmd() { +// NBCLIOptions opts = new NBCLIOptions(new String[]{ "start", "driver=woot" }); +// List cmds = opts.getCommands(); +// assertThat(cmds).hasSize(1); +// assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.start); +// +// } +// +// @Test +// public void shouldRecognizeRunActivityCmd() { +// NBCLIOptions opts = new NBCLIOptions(new String[]{ "run", "driver=runwoot" }); +// List cmds = opts.getCommands(); +// assertThat(cmds).hasSize(1); +// assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.run); +// +// } // @Test // public void shouldRecognizeStopActivityCmd() { @@ -172,14 +172,14 @@ public class TestNBCLIOptions { .isThrownBy(() -> new NBCLIOptions(new String[]{ "stop", "woah=woah" })); } - @Test - public void shouldRecognizeAwaitActivityCmd() { - NBCLIOptions opts = new NBCLIOptions(new String[]{ "await", "activity=awaitme" }); - List cmds = opts.getCommands(); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.await); - assertThat(cmds.get(0).getArgValue("activity")).isEqualTo("awaitme"); - - } +// @Test +// public void shouldRecognizeAwaitActivityCmd() { +// NBCLIOptions opts = new NBCLIOptions(new String[]{ "await", "activity=awaitme" }); +// List cmds = opts.getCommands(); +// assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.await); +// assertThat(cmds.get(0).getArgValue("activity")).isEqualTo("awaitme"); +// +// } @Disabled("semantic parsing is reserved until later after generalizing syntax") @Test @@ -188,14 +188,14 @@ public class TestNBCLIOptions { .isThrownBy(() -> new NBCLIOptions(new String[]{ "await", "awaitme=notvalid" })); } - @Test - public void shouldRecognizewaitMillisCmd() { - NBCLIOptions opts = new NBCLIOptions(new String[]{ "waitmillis", "ms=23234" }); - List cmds = opts.getCommands(); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.waitMillis); - assertThat(cmds.get(0).getArgValue("ms")).isEqualTo("23234"); - - } +// @Test +// public void shouldRecognizewaitMillisCmd() { +// NBCLIOptions opts = new NBCLIOptions(new String[]{ "waitmillis", "ms=23234" }); +// List cmds = opts.getCommands(); +// assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.waitMillis); +// assertThat(cmds.get(0).getArgValue("ms")).isEqualTo("23234"); +// +// } @Test public void listWorkloads() { diff --git a/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/BasicScriptBuffer.java b/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/BasicScriptBuffer.java index 1e7c26fa4..6ff7002b5 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/BasicScriptBuffer.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/BasicScriptBuffer.java @@ -74,12 +74,7 @@ public class BasicScriptBuffer implements ScriptBuffer { } break; case java: - case start: // start activity - case run: // run activity - case await: // await activity // case stop: // stop activity - case forceStop: // force stopping activity - case waitMillis: sb.append("controller.").append(cmd.asScriptText()).append("\n"); //// // Sanity check that this can parse before using it diff --git a/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/CmdType.java b/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/CmdType.java index 5cf98c180..6de8dc98e 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/CmdType.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/CmdType.java @@ -23,14 +23,14 @@ package io.nosqlbench.engine.cmdstream; * or an error is thrown. */ public enum CmdType { - run(), - start(), +// run(), +// start(), // stop(CmdParam.of("activity")), - forceStop(CmdParam.of("activity")), +// forceStop(CmdParam.of("activity")), script(CmdParam.of("path", s -> s)), java(CmdParam.of("class", s -> s)), - await(CmdParam.of("activity")), - waitMillis(CmdParam.of("ms", Long::parseLong)), +// await(CmdParam.of("activity")), +// waitMillis(CmdParam.of("ms", Long::parseLong)), fragment(CmdParam.ofFreeform("fragment")), container(CmdParam.of("name")), indirect(CmdParam.of("indirect")); diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_await.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_await.java new file mode 100644 index 000000000..9d8d5b1d1 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_await.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; +import io.nosqlbench.nb.annotations.Service; +import io.nosqlbench.nb.api.engine.util.Unit; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.io.PrintWriter; +import java.io.Reader; +import java.util.concurrent.locks.LockSupport; + +@Service(value = NBBaseCommand.class, selector = "await") +public class CMD_await extends NBBaseCommand { + public final static Logger logger = LogManager.getLogger("await"); + + public CMD_await(NBBufferedContainer parentComponent, String stepName, String targetScenario) { + super(parentComponent, stepName, targetScenario); + } + + @Override + public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) { + controller.await(params); + return null; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_example.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_example.java new file mode 100644 index 000000000..8585ad508 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_example.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.api.activityapi.core.Activity; +import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; +import io.nosqlbench.nb.annotations.Service; +import io.nosqlbench.nb.api.errors.BasicError; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.io.PrintWriter; +import java.io.Reader; +import java.util.Optional; + +@Service(value = NBBaseCommand.class,selector = "example") +public class CMD_example extends NBBaseCommand { + public final static Logger logger = LogManager.getLogger("example"); + + public CMD_example(NBBufferedContainer parentComponent, String stepName, String targetScenario) { + super(parentComponent, stepName, targetScenario); + } + + @Override + public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) { + return null; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_forceStop.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_forceStop.java new file mode 100644 index 000000000..41c34f4be --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_forceStop.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.api.activityapi.core.Activity; +import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; +import io.nosqlbench.nb.annotations.Service; +import io.nosqlbench.nb.api.errors.BasicError; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.io.PrintWriter; +import java.io.Reader; +import java.util.Optional; + +@Service(value = NBBaseCommand.class,selector = "force_stop") +public class CMD_forceStop extends NBBaseCommand { + public final static Logger logger = LogManager.getLogger("force_stop"); + + public CMD_forceStop(NBBufferedContainer parentComponent, String stepName, String targetScenario) { + super(parentComponent, stepName, targetScenario); + } + + @Override + public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) { + controller.forceStop(params); + return null; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_run.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_run.java new file mode 100644 index 000000000..6d9e9fc6e --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_run.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; +import io.nosqlbench.nb.annotations.Service; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.io.PrintWriter; +import java.io.Reader; + +@Service(value = NBBaseCommand.class, selector = "run") +public class CMD_run extends NBBaseCommand { + public final static Logger logger = LogManager.getLogger("run"); + + public CMD_run(NBBufferedContainer parentComponent, String stepName, String targetScenario) { + super(parentComponent, stepName, targetScenario); + } + + @Override + public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) { + controller.run(params); + return null; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_start.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_start.java new file mode 100644 index 000000000..d093fcb99 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_start.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.api.activityapi.core.Activity; +import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; +import io.nosqlbench.nb.annotations.Service; +import io.nosqlbench.nb.api.errors.BasicError; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.io.PrintWriter; +import java.io.Reader; +import java.util.Optional; + +@Service(value = NBBaseCommand.class,selector = "start") +public class CMD_start extends NBBaseCommand { + public final static Logger logger = LogManager.getLogger("start"); + + public CMD_start(NBBufferedContainer parentComponent, String stepName, String targetScenario) { + super(parentComponent, stepName, targetScenario); + } + + @Override + public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) { + return controller.start(params); + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_wait.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_wait.java new file mode 100644 index 000000000..714ae5cc0 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/CMD_wait.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import com.amazonaws.services.s3.model.transform.Unmarshallers; +import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; +import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; +import io.nosqlbench.nb.annotations.Service; +import io.nosqlbench.nb.api.engine.util.Unit; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.io.PrintWriter; +import java.io.Reader; +import java.util.Optional; +import java.util.concurrent.locks.LockSupport; +import java.util.stream.LongStream; + +@Service(value = NBBaseCommand.class, selector = "example") +public class CMD_wait extends NBBaseCommand { + public final static Logger logger = LogManager.getLogger("example"); + + public CMD_wait(NBBufferedContainer parentComponent, String stepName, String targetScenario) { + super(parentComponent, stepName, targetScenario); + } + + @Override + public Object invoke(NBCommandParams params, PrintWriter stdout, PrintWriter stderr, Reader stdin, ContainerActivitiesController controller) { + long ns = 0L; + ns += params.maybeGet("ms") + .or(() -> params.maybeGet("millis")) + .map(Long::parseLong) + .map(l -> l * 1_000_000L) + .orElse(0L); + ns += params.maybeGet("us") + .or(() -> params.maybeGet("micros")) + .map(Long::parseLong) + .map(l -> l * 1_000L) + .orElse(0L); + ns += params.maybeGet("ns") + .or(() -> params.maybeGet("nanos")) + .map(Long::parseLong) + .orElse(0L); + ns += params.maybeGet("unit") + .flatMap(Unit::nanosecondsFor) + .orElse(0L); + LockSupport.parkNanos(ns); + return ns; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_await.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_await.java new file mode 100644 index 000000000..2f5888f7a --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_await.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand; +import io.nosqlbench.nb.annotations.Service; + +@Service(value = NBCommandInfo.class,selector = "await") +public class INFO_await extends NBCommandInfo { + @Override + public Class getType() { + return CMD_await.class; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java new file mode 100644 index 000000000..4530b1a7c --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand; +import io.nosqlbench.nb.annotations.Service; + +@Service(value = NBCommandInfo.class,selector = "start") +public class INFO_example extends NBCommandInfo { + @Override + public Class getType() { + return CMD_example.class; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_forceStop.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_forceStop.java new file mode 100644 index 000000000..cf77bbd44 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_forceStop.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand; +import io.nosqlbench.nb.annotations.Service; + +@Service(value = NBCommandInfo.class,selector = "force_stop") +public class INFO_forceStop extends NBCommandInfo { + @Override + public Class getType() { + return CMD_forceStop.class; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_run.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_run.java new file mode 100644 index 000000000..b0574b2c6 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_run.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand; +import io.nosqlbench.nb.annotations.Service; + +@Service(value = NBCommandInfo.class,selector = "run") +public class INFO_run extends NBCommandInfo { + @Override + public Class getType() { + return CMD_run.class; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_start.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_start.java new file mode 100644 index 000000000..2df93b41b --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_start.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand; +import io.nosqlbench.nb.annotations.Service; + +@Service(value = NBCommandInfo.class,selector = "start") +public class INFO_start extends NBCommandInfo { + @Override + public Class getType() { + return CMD_start.class; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_wait.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_wait.java new file mode 100644 index 000000000..e2900a8c1 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_wait.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.commands; + +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand; +import io.nosqlbench.nb.annotations.Service; + +@Service(value = NBCommandInfo.class,selector = "wait") +public class INFO_wait extends NBCommandInfo { + @Override + public Class getType() { + return CMD_wait.class; + } +} diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBScriptCommandResolver.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBScriptCommandResolver.java index 842ac09fe..35f57877e 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBScriptCommandResolver.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBScriptCommandResolver.java @@ -27,7 +27,7 @@ public class NBScriptCommandResolver implements NBInvokableResolver { @Override public NBInvokableCommand resolve(Cmd cmd, NBBufferedContainer parent, String phaseName) { return switch (cmd.getCmdType()) { - case run, await, forceStop, start, waitMillis, fragment, script-> + case fragment, script-> new NBScriptedCommand(parent, phaseName, cmd.getTargetContext()).add(cmd); // case fragment -> // new NBScriptedCommand(parent, phaseName, cmd.getTargetContext()).addScriptText(cmd.getArgValue("fragment")); diff --git a/engine-core/src/test/java/io/nosqlbench/engine/core/lifecycle/session/CmdParserTest.java b/engine-core/src/test/java/io/nosqlbench/engine/core/lifecycle/session/CmdParserTest.java index 66272b9ab..086d0dfe4 100644 --- a/engine-core/src/test/java/io/nosqlbench/engine/core/lifecycle/session/CmdParserTest.java +++ b/engine-core/src/test/java/io/nosqlbench/engine/core/lifecycle/session/CmdParserTest.java @@ -19,6 +19,7 @@ package io.nosqlbench.engine.core.lifecycle.session; import io.nosqlbench.engine.cmdstream.Cmd; import io.nosqlbench.engine.cmdstream.CmdType; import io.nosqlbench.nb.api.errors.BasicError; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import java.util.LinkedList; @@ -34,36 +35,37 @@ class CmdParserTest { public void testSingleCommand() { List cmds = CmdParser.parse("testcmd42"); assertThat(cmds).hasSize(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.indirect); - assertThat(cmds.get(0).getArgValue("_impl")).isEqualTo("testcmd42"); + assertThat(cmds.getFirst().getCmdType()).isEqualTo(CmdType.indirect); + assertThat(cmds.getFirst().getArgValue("_impl")).isEqualTo("testcmd42"); } @Test public void testSingleCommandWithArgs() { List cmds = CmdParser.parse("testcmd43 param1=value1"); assertThat(cmds).hasSize(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.indirect); - assertThat(cmds.get(0).getArgValue("_impl")).isEqualTo("testcmd43"); - assertThat(cmds.get(0).getArgValue("param1")).isEqualTo("value1"); + assertThat(cmds.getFirst().getCmdType()).isEqualTo(CmdType.indirect); + assertThat(cmds.getFirst().getArgValue("_impl")).isEqualTo("testcmd43"); + assertThat(cmds.getFirst().getArgValue("param1")).isEqualTo("value1"); } @Test public void testSingleDquotedArg() { List cmds = CmdParser.parse("testcmd44 param1=\"value1\""); assertThat(cmds).hasSize(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.indirect); - assertThat(cmds.get(0).getArgValue("_impl")).isEqualTo("testcmd44"); - assertThat(cmds.get(0).getArgValue("param1")).isEqualTo("value1"); + assertThat(cmds.getFirst().getCmdType()).isEqualTo(CmdType.indirect); + assertThat(cmds.getFirst().getArgValue("_impl")).isEqualTo("testcmd44"); + assertThat(cmds.getFirst().getArgValue("param1")).isEqualTo("value1"); } + @Disabled @Test public void testSpecialSymbolValue() { List cmds = CmdParser.parse("start param1="+ CmdParser.SYMBOLS+ " param2='"+ CmdParser.SYMBOLS+ "' param3=\""+ CmdParser.SYMBOLS+ "\""); assertThat(cmds).hasSize(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.start); - assertThat(cmds.get(0).getArgValue("param1")).isEqualTo(CmdParser.SYMBOLS); - assertThat(cmds.get(0).getArgValue("param2")).isEqualTo(CmdParser.SYMBOLS); - assertThat(cmds.get(0).getArgValue("param3")).isEqualTo(CmdParser.SYMBOLS); +// assertThat(cmds.getFirst().getCmdType()).isEqualTo(CmdType.start); + assertThat(cmds.getFirst().getArgValue("param1")).isEqualTo(CmdParser.SYMBOLS); + assertThat(cmds.getFirst().getArgValue("param2")).isEqualTo(CmdParser.SYMBOLS); + assertThat(cmds.getFirst().getArgValue("param3")).isEqualTo(CmdParser.SYMBOLS); } @Test @@ -76,23 +78,24 @@ class CmdParserTest { "an error should be thrown if a named parameter is specified without a prior command."); } + @Disabled @Test public void testThatSymbolsAreQuotedInStringForm() { List cmds = CmdParser.parse("start param1=value1 param2='~should be quoted'"); assertThat(cmds.size()).isEqualTo(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.start); - assertThat(cmds.get(0).getArgValue("param1")).isEqualTo("value1"); - assertThat(cmds.get(0).getArgValue("param2")).isEqualTo("~should be quoted"); - assertThat(cmds.get(0).toString()).isEqualTo("start param1=value1 param2='~should be quoted'"); +// assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.start); + assertThat(cmds.getFirst().getArgValue("param1")).isEqualTo("value1"); + assertThat(cmds.getFirst().getArgValue("param2")).isEqualTo("~should be quoted"); + assertThat(cmds.getFirst().toString()).isEqualTo("start param1=value1 param2='~should be quoted'"); } @Test public void testBasicArgvParser() { LinkedList cmds = CmdParser.parseArgvCommands(new LinkedList<>(List.of("_cmd4", "param1=value1"))); assertThat(cmds.size()).isEqualTo(1); - assertThat(cmds.get(0).getCmdType()).isEqualTo(CmdType.indirect); - assertThat(cmds.get(0).getArgValue("_impl")).isEqualTo("_cmd4"); - assertThat(cmds.get(0).getArgValue("param1")).isEqualTo("value1"); + assertThat(cmds.getFirst().getCmdType()).isEqualTo(CmdType.indirect); + assertThat(cmds.getFirst().getArgValue("_impl")).isEqualTo("_cmd4"); + assertThat(cmds.getFirst().getArgValue("param1")).isEqualTo("value1"); } } diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 384654081..ecb00451d 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -361,12 +361,12 @@ org.graalvm.sdk graal-sdk - 23.1.1 + 23.0.1 org.graalvm.js js - 23.0.2 + 23.0.1 runtime From 4e9963ab17fc5a1c065d8c45b4399751e3971972 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 19 Dec 2023 00:01:28 -0600 Subject: [PATCH 002/120] optimizer naming updates, fixes for _impl --- .../engine/cli/NBJavaNativeResolver.java | 5 ++- .../io/nosqlbench/engine/cmdstream/Cmd.java | 6 +++ .../core/lifecycle/commands/INFO_example.java | 2 +- .../lifecycle/session/NBCommandAssembly.java | 1 + .../java/io/nosqlbench/nb/PlaceHolder.java | 24 ----------- .../simframe/{optimo => }/SimFrameUtils.java | 3 +- .../SimFrameValueData.java} | 12 +++--- .../package-info.java} | 12 +++--- .../simframe/generic/ParamsEffector.java | 23 ----------- .../CMD_optimize.java} | 19 ++++----- .../INFO_optimize.java} | 9 ++--- .../planners/OptimizerPlannerTypes.java} | 20 ++++----- .../planners/findmax/FindmaxConfig.java} | 6 +-- .../planners/findmax/FindmaxFrameParams.java} | 38 +++++++++--------- .../planners/findmax/FindmaxPlanner.java} | 32 +++++++-------- .../planners}/findmax/findmax.png | Bin .../planners}/findmax/findmax.svg | 0 .../planners/ratchet/RatchetConfig.java | 2 +- .../planners/ratchet/RatchetFrameParams.java | 4 +- .../planners/ratchet/RatchetPlanner.java} | 8 ++-- .../planners/rcurve/RCurveConfig.java} | 18 ++++++--- .../planners/rcurve/RCurveFrameParams.java} | 7 ++-- .../planners/rcurve/RCurvePlanner.java} | 30 ++++++++------ .../scenarios/simframe/optimo/NB_optimo.java | 5 ++- 24 files changed, 128 insertions(+), 158 deletions(-) delete mode 100644 nbr/src/main/java/io/nosqlbench/nb/PlaceHolder.java rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{optimo => }/SimFrameUtils.java (98%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/FindmaxFrameData.java => capture/SimFrameValueData.java} (89%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{optimo/ThreadSpec.java => capture/package-info.java} (68%) delete mode 100644 nbr/src/main/java/io/nosqlbench/scenarios/simframe/generic/ParamsEffector.java rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/NB_findmax.java => optimizers/CMD_optimize.java} (81%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/NBFindmaxInfo.java => optimizers/INFO_optimize.java} (77%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/planners/FindmaxPlannerType.java => optimizers/planners/OptimizerPlannerTypes.java} (62%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/planners/rampup/RampupConfig.java => optimizers/planners/findmax/FindmaxConfig.java} (91%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/planners/rampup/RampupFrameParams.java => optimizers/planners/findmax/FindmaxFrameParams.java} (68%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/planners/rampup/FindmaxRampup.java => optimizers/planners/findmax/FindmaxPlanner.java} (81%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{ => optimizers/planners}/findmax/findmax.png (100%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{ => optimizers/planners}/findmax/findmax.svg (100%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax => optimizers}/planners/ratchet/RatchetConfig.java (96%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax => optimizers}/planners/ratchet/RatchetFrameParams.java (84%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/planners/ratchet/FindmaxRatchet.java => optimizers/planners/ratchet/RatchetPlanner.java} (93%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/survey/SurveyConfig.java => optimizers/planners/rcurve/RCurveConfig.java} (72%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/survey/SurveyFrameParams.java => optimizers/planners/rcurve/RCurveFrameParams.java} (84%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{findmax/survey/FindmaxSurvey.java => optimizers/planners/rcurve/RCurvePlanner.java} (67%) diff --git a/engine-cli/src/main/java/io/nosqlbench/engine/cli/NBJavaNativeResolver.java b/engine-cli/src/main/java/io/nosqlbench/engine/cli/NBJavaNativeResolver.java index 27357cc77..e23242a47 100644 --- a/engine-cli/src/main/java/io/nosqlbench/engine/cli/NBJavaNativeResolver.java +++ b/engine-cli/src/main/java/io/nosqlbench/engine/cli/NBJavaNativeResolver.java @@ -29,7 +29,10 @@ public class NBJavaNativeResolver implements NBInvokableResolver { @Override public NBInvokableCommand resolve(Cmd cmd, NBBufferedContainer parent, String phaseName) { return switch (cmd.getCmdType()) { - case CmdType.indirect -> NBJavaCommandLoader.init(cmd.getArgValue("_impl"), parent, phaseName, cmd.getTargetContext()); + case CmdType.indirect -> { + String implName = cmd.takeArgValue("_impl"); + yield NBJavaCommandLoader.init(implName, parent, phaseName, cmd.getTargetContext()); + } case CmdType.java -> NBJavaCommandLoader.init(cmd.getArgValue("class"), parent, phaseName, cmd.getTargetContext()); default -> null; }; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/Cmd.java b/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/Cmd.java index 8cd551e22..e1d057073 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/Cmd.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/cmdstream/Cmd.java @@ -55,6 +55,12 @@ public class Cmd { return cmdArg.getValue(); } + + public String takeArgValue(String paramName) { + String argValue = getArgValue(paramName); + this.cmdArgs.remove(paramName); + return argValue; + } public String getArgValue(String paramName) { CmdArg cmdArg = this.cmdArgs.get(paramName); if (cmdArg==null) { diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java index 4530b1a7c..6d9c2aa7b 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/commands/INFO_example.java @@ -20,7 +20,7 @@ import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBInvokableCommand; import io.nosqlbench.nb.annotations.Service; -@Service(value = NBCommandInfo.class,selector = "start") +@Service(value = NBCommandInfo.class,selector = "example") public class INFO_example extends NBCommandInfo { @Override public Class getType() { diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java index c21fc3d73..d1a0de12e 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java @@ -77,6 +77,7 @@ public class NBCommandAssembly { throw new BasicError("Found zero commands for spec;" + cmd); } String containerName = cmd.getTargetContext(); + params.remove("_impl"); parameterizedInvocations.add(new CommandInvocation(command, params, containerName)); } return parameterizedInvocations; diff --git a/nbr/src/main/java/io/nosqlbench/nb/PlaceHolder.java b/nbr/src/main/java/io/nosqlbench/nb/PlaceHolder.java deleted file mode 100644 index 0b0f52c25..000000000 --- a/nbr/src/main/java/io/nosqlbench/nb/PlaceHolder.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (c) 2022 nosqlbench - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.nosqlbench.nb; - -/** - * This class is just a place holder. It holds a place. - * If only nexus understood aggregator module without src... - */ -public class PlaceHolder { -} diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/SimFrameUtils.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/SimFrameUtils.java similarity index 98% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/SimFrameUtils.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/SimFrameUtils.java index ba93cd721..4da4f34e5 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/SimFrameUtils.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/SimFrameUtils.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; +package io.nosqlbench.scenarios.simframe; import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; @@ -28,7 +28,6 @@ import java.util.concurrent.locks.LockSupport; public class SimFrameUtils { - public static void awaitActivity(Activity flywheel) { // await flywheel actually spinning, or timeout with error NBMetricTimer result_success_timer = flywheel.find().timer("name:result_success"); diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/FindmaxFrameData.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/capture/SimFrameValueData.java similarity index 89% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/FindmaxFrameData.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/capture/SimFrameValueData.java index 8b0b40bdf..e5e1e8c68 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/FindmaxFrameData.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/capture/SimFrameValueData.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax; +package io.nosqlbench.scenarios.simframe.capture; import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge; @@ -22,8 +22,8 @@ import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricHistogram; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer; import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture; -public class FindmaxFrameData extends SimFrameCapture { - public FindmaxFrameData(Activity activity) { +public class SimFrameValueData extends SimFrameCapture { + public SimFrameValueData(Activity activity) { NBMetricTimer result_timer = activity.find().timer("name:result"); NBMetricTimer result_success_timer = activity.find().timer("name:result_success"); NBMetricGauge cyclerate_gauge = activity.find().gauge("name=config_cyclerate"); @@ -31,13 +31,13 @@ public class FindmaxFrameData extends SimFrameCapture { NBMetricHistogram tries_histo = tries_histo_src.attachHdrDeltaHistogram(); addDirect("target_rate", - () -> cyclerate_gauge.getValue(), + cyclerate_gauge::getValue, Double.NaN); addDeltaTime("achieved_oprate", - () -> result_timer.getCount(), + result_timer::getCount, Double.NaN); addDeltaTime("achieved_ok_oprate", - () -> result_success_timer.getCount() + result_success_timer::getCount , 1.0); addRemix("achieved_success_ratio", vars -> { diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/ThreadSpec.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/capture/package-info.java similarity index 68% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/ThreadSpec.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/capture/package-info.java index 3672948be..940b18330 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/ThreadSpec.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/capture/package-info.java @@ -14,9 +14,9 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; - -public class ThreadSpec { - public ThreadSpec(double threads) { - } -} +/** + * The types in this package are used to define observable dependent variables, + * specify how they are measured, formulate them into a value function, and provide + * a view of these over time as frames are executed. + */ +package io.nosqlbench.scenarios.simframe.capture; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/generic/ParamsEffector.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/generic/ParamsEffector.java deleted file mode 100644 index a98b69b38..000000000 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/generic/ParamsEffector.java +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright (c) 2023 nosqlbench - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.nosqlbench.scenarios.simframe.generic; - -import io.nosqlbench.engine.api.activityapi.core.Activity; - -public interface ParamsEffector

{ - P applyParams(P ptype, Activity activity); -} diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/NB_findmax.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/CMD_optimize.java similarity index 81% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/NB_findmax.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/CMD_optimize.java index 2f29e26a4..211fa32ab 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/NB_findmax.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/CMD_optimize.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax; +package io.nosqlbench.scenarios.simframe.optimizers; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; @@ -23,8 +23,9 @@ import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitie import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; import io.nosqlbench.nb.annotations.Service; import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture; -import io.nosqlbench.scenarios.simframe.findmax.planners.FindmaxPlannerType; -import io.nosqlbench.scenarios.simframe.optimo.SimFrameUtils; +import io.nosqlbench.scenarios.simframe.capture.SimFrameValueData; +import io.nosqlbench.scenarios.simframe.optimizers.planners.OptimizerPlannerTypes; +import io.nosqlbench.scenarios.simframe.SimFrameUtils; import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -52,11 +53,11 @@ import java.io.Reader; * *

This can be tested as 

{@code nb5 --show-stacktraces java io.nosqlbench.scenarios.findmax.SC_findmax threads=36}

*/ -@Service(value = NBBaseCommand.class,selector = "findmax") -public class NB_findmax extends NBBaseCommand { - private final static Logger logger = LogManager.getLogger(NB_findmax.class); +@Service(value = NBBaseCommand.class,selector = "optimize") +public class CMD_optimize extends NBBaseCommand { + private final static Logger logger = LogManager.getLogger(CMD_optimize.class); - public NB_findmax(NBBufferedContainer parentComponent, String scenarioName, String context) { + public CMD_optimize(NBBufferedContainer parentComponent, String scenarioName, String context) { super(parentComponent, scenarioName, context); } @@ -65,9 +66,9 @@ public class NB_findmax extends NBBaseCommand { Activity flywheel = SimFrameUtils.findFlywheelActivity(controller, params.get("activity")); stdout.println("starting analysis on activity '" + flywheel.getAlias() + "'"); SimFrameUtils.awaitActivity(flywheel); - SimFrameCapture capture = new FindmaxFrameData(flywheel); + SimFrameCapture capture = new SimFrameValueData(flywheel); String plannerType = params.getOrDefault("planner", "ratchet"); - FindmaxPlannerType plannerImpl = FindmaxPlannerType.valueOf(plannerType); + OptimizerPlannerTypes plannerImpl = OptimizerPlannerTypes.valueOf(plannerType); SimFramePlanner planner = plannerImpl.createPlanner(params); Record result = planner.analyze(flywheel, capture, stdout, stderr, controller); stdout.println("result:\n" + result); diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/NBFindmaxInfo.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/INFO_optimize.java similarity index 77% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/NBFindmaxInfo.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/INFO_optimize.java index 7d9b09e6d..352b1d387 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/NBFindmaxInfo.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/INFO_optimize.java @@ -14,17 +14,16 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax; +package io.nosqlbench.scenarios.simframe.optimizers; import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; import io.nosqlbench.nb.annotations.Service; -import io.nosqlbench.scenarios.simframe.optimo.NB_optimo; -@Service(value = NBCommandInfo.class,selector = "findmax") -public class NBFindmaxInfo extends NBCommandInfo { +@Service(value = NBCommandInfo.class,selector = "optimize") +public class INFO_optimize extends NBCommandInfo { @Override public Class getType() { - return NB_findmax.class; + return CMD_optimize.class; } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/FindmaxPlannerType.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/OptimizerPlannerTypes.java similarity index 62% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/FindmaxPlannerType.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/OptimizerPlannerTypes.java index 9bf6b8b8c..184fdffbe 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/FindmaxPlannerType.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/OptimizerPlannerTypes.java @@ -14,25 +14,25 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax.planners; +package io.nosqlbench.scenarios.simframe.optimizers.planners; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; -import io.nosqlbench.scenarios.simframe.findmax.planners.rampup.FindmaxRampup; -import io.nosqlbench.scenarios.simframe.findmax.planners.ratchet.FindmaxRatchet; -import io.nosqlbench.scenarios.simframe.findmax.survey.FindmaxSurvey; +import io.nosqlbench.scenarios.simframe.optimizers.planners.findmax.FindmaxPlanner; +import io.nosqlbench.scenarios.simframe.optimizers.planners.ratchet.RatchetPlanner; +import io.nosqlbench.scenarios.simframe.optimizers.planners.rcurve.RCurvePlanner; import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner; -public enum FindmaxPlannerType { +public enum OptimizerPlannerTypes { // survey, ratchet, - rampup, - survey, + findmax, + rcurve, ; public SimFramePlanner createPlanner(NBCommandParams params) { return switch (this) { - case ratchet -> new FindmaxRatchet(params); - case rampup -> new FindmaxRampup(params); - case survey -> new FindmaxSurvey(params); + case findmax -> new FindmaxPlanner(params); + case rcurve -> new RCurvePlanner(params); + case ratchet -> new RatchetPlanner(params); }; } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/RampupConfig.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxConfig.java similarity index 91% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/RampupConfig.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxConfig.java index a70dc43d5..2f4a5602e 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/RampupConfig.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxConfig.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax.planners.rampup; +package io.nosqlbench.scenarios.simframe.optimizers.planners.findmax; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; @@ -22,7 +22,7 @@ import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; * These search parameters are based on the original findmax algorithm, and * should be reduced down to the minimum set needed. */ -public record RampupConfig( +public record FindmaxConfig( int sample_time_ms, int sample_max, double sample_incr, @@ -32,7 +32,7 @@ public record RampupConfig( int average_of, long min_settling_ms ) { - public RampupConfig(NBCommandParams params) { + public FindmaxConfig(NBCommandParams params) { this( params.maybeGet("sample_time_ms").map(Integer::parseInt).orElse(4000), params.maybeGet("sample_max").map(Integer::parseInt).orElse(10000), diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/RampupFrameParams.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxFrameParams.java similarity index 68% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/RampupFrameParams.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxFrameParams.java index a4391340f..733a7b3c1 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/RampupFrameParams.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxFrameParams.java @@ -14,34 +14,34 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax.planners.rampup; +package io.nosqlbench.scenarios.simframe.optimizers.planners.findmax; /** * These parameters are calculated by the planner based on previous simulation frame history. */ -public record RampupFrameParams( +public record FindmaxFrameParams( /** * The base rate upon which we add higher deltas */ double rate_shelf, - /** - * The incremental rate which we stack on top of the base rate to find a new limit - */ - double rate_delta, - /** - * How many millis we sample the current frame for - */ - long sample_time_ms, - /** - * How many millis we let the workload settle for to achieve stability, such as when it has recently - * be in in over-saturation mode with a too-high delta - */ - long settling_time_ms, - /** - * Narrate the reason for the current parameters being set the way the are - */ - String description + /** + * The incremental rate which we stack on top of the base rate to find a new limit + */ + double rate_delta, + /** + * How many millis we sample the current frame for + */ + long sample_time_ms, + /** + * How many millis we let the workload settle for to achieve stability, such as when it has recently + * be in in over-saturation mode with a too-high delta + */ + long settling_time_ms, + /** + * Narrate the reason for the current parameters being set the way the are + */ + String description ) { public double computed_rate() { diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/FindmaxRampup.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java similarity index 81% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/FindmaxRampup.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java index fa757d8b5..ed597db07 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/planners/rampup/FindmaxRampup.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax.planners.rampup; +package io.nosqlbench.scenarios.simframe.optimizers.planners.findmax; import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; @@ -29,20 +29,20 @@ import org.apache.logging.log4j.Logger; import java.util.Comparator; -public class FindmaxRampup extends SimFramePlanner { - private final Logger logger = LogManager.getLogger(FindmaxRampup.class); +public class FindmaxPlanner extends SimFramePlanner { + private final Logger logger = LogManager.getLogger(FindmaxPlanner.class); - public FindmaxRampup(NBCommandParams analyzerParams) { + public FindmaxPlanner(NBCommandParams analyzerParams) { super(analyzerParams); } @Override - public RampupConfig getConfig(NBCommandParams params) { - return new RampupConfig(params); + public FindmaxConfig getConfig(NBCommandParams params) { + return new FindmaxConfig(params); } - public RampupFrameParams initialStep() { - return new RampupFrameParams( + public FindmaxFrameParams initialStep() { + return new FindmaxFrameParams( config.rate_base(), config.rate_step(), config.sample_time_ms(), config.min_settling_ms(), "INITIAL" ); } @@ -57,11 +57,11 @@ public class FindmaxRampup extends SimFramePlanner journal) { - SimFrame last = journal.last(); - SimFrame best = journal.bestRun(); + public FindmaxFrameParams nextStep(JournalView journal) { + SimFrame last = journal.last(); + SimFrame best = journal.bestRun(); if (best.index() == last.index()) { // got better consecutively - return new RampupFrameParams( + return new FindmaxFrameParams( last.params().rate_shelf(), last.params().rate_delta() * config.rate_incr(), last.params().sample_time_ms(), @@ -74,7 +74,7 @@ public class FindmaxRampup extends SimFramePlanner nextWorseFrameWithHigherRate = journal.frames().stream() + SimFrame nextWorseFrameWithHigherRate = journal.frames().stream() .filter(f -> f.value() < best.value()) .filter(f -> f.params().computed_rate() > best.params().computed_rate()) .min(Comparator.comparingDouble(f -> f.params().computed_rate())) .orElseThrow(() -> new RuntimeException("inconsistent samples")); if ((nextWorseFrameWithHigherRate.params().computed_rate() - best.params().computed_rate()) > config.rate_step()) { - return new RampupFrameParams( + return new FindmaxFrameParams( best.params().computed_rate(), config.rate_step(), (long) (last.params().sample_time_ms() * config.sample_incr()), @@ -105,7 +105,7 @@ public class FindmaxRampup extends SimFramePlanner { - private final Logger logger = LogManager.getLogger(FindmaxRatchet.class); +public class RatchetPlanner extends SimFramePlanner { + private final Logger logger = LogManager.getLogger(RatchetPlanner.class); - public FindmaxRatchet(NBCommandParams params) { + public RatchetPlanner(NBCommandParams params) { super(params); } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/SurveyConfig.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java similarity index 72% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/SurveyConfig.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java index 6a7eb67ca..62342c5af 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/SurveyConfig.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax.survey; +package io.nosqlbench.scenarios.simframe.optimizers.planners.rcurve; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; @@ -22,15 +22,21 @@ import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; * These search parameters are based on the original findmax algorithm, and * should be reduced down to the minimum set needed. */ -public record SurveyConfig( +public record RCurveConfig( + double min_rate, double max_rate, int steps ) { - public SurveyConfig(NBCommandParams params) { + public RCurveConfig(NBCommandParams params) { this( - params.maybeGet("max_rate").map(Double::parseDouble).orElse(1.2d), - params.maybeGet("steps").map(Integer::parseInt).orElse(3) + params.maybeGet("min_rate").map(Double::parseDouble).orElse(0.0), + params.maybeGet("max_rate").map(Double::parseDouble).orElse(10.0), + params.maybeGet("steps").map(Integer::parseInt).orElse(10) ); - } + + double rateForStep(int step) { + return min_rate + ((max_rate-min_rate)*((double)step/(double)steps)); + } + } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/SurveyFrameParams.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveFrameParams.java similarity index 84% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/SurveyFrameParams.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveFrameParams.java index 411becca1..db0893390 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/SurveyFrameParams.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveFrameParams.java @@ -14,12 +14,11 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax.survey; +package io.nosqlbench.scenarios.simframe.optimizers.planners.rcurve; -public record SurveyFrameParams( +public record RCurveFrameParams( double rate, - double step, + int step, String description - ) { } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/FindmaxSurvey.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java similarity index 67% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/FindmaxSurvey.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java index 1bfd712ed..af2868fda 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/findmax/survey/FindmaxSurvey.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.findmax.survey; +package io.nosqlbench.scenarios.simframe.optimizers.planners.rcurve; import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; @@ -27,21 +27,21 @@ import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -public class FindmaxSurvey extends SimFramePlanner { - private final Logger logger = LogManager.getLogger(FindmaxSurvey.class); +public class RCurvePlanner extends SimFramePlanner { + private final Logger logger = LogManager.getLogger(RCurvePlanner.class); - public FindmaxSurvey(NBCommandParams params) { + public RCurvePlanner(NBCommandParams params) { super(params); } @Override - public SurveyConfig getConfig(NBCommandParams params) { - return new SurveyConfig(params); + public RCurveConfig getConfig(NBCommandParams params) { + return new RCurveConfig(params); } - public SurveyFrameParams initialStep() { - return new SurveyFrameParams(config.max_rate(), config.steps(), "INITIAL"); + public RCurveFrameParams initialStep() { + return new RCurveFrameParams(config.rateForStep(1), 1, "INITIAL"); } /** @@ -55,14 +55,18 @@ public class FindmaxSurvey extends SimFramePlanner journal) { - return null; + public RCurveFrameParams nextStep(JournalView journal) { + SimFrame last = journal.last(); + int nextStep = last.params().step() +1; + if (nextStep<=config.steps()) { + return new RCurveFrameParams(config.rateForStep(nextStep),nextStep,"Advancing to step " + nextStep); + } else { + return null; + } } - @Override - public void applyParams(SurveyFrameParams params, Activity flywheel) { + public void applyParams(RCurveFrameParams params, Activity flywheel) { flywheel.onEvent(ParamChange.of(new CycleRateSpec(params.rate(), 1.1d, SimRateSpec.Verb.restart))); - } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java index 3ecca4ebd..e2b6ff4ca 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java @@ -28,9 +28,10 @@ import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.scenarios.simframe.SimFrameUtils; import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture; import io.nosqlbench.scenarios.simframe.capture.SimFrameJournal; -import io.nosqlbench.scenarios.simframe.findmax.NB_findmax; +import io.nosqlbench.scenarios.simframe.optimizers.CMD_optimize; import io.nosqlbench.scenarios.simframe.planning.SimFrame; import io.nosqlbench.scenarios.simframe.planning.SimFrameFunction; import io.nosqlbench.scenarios.simframe.stabilization.StatFunctions; @@ -63,7 +64,7 @@ import java.util.List; * */ public class NB_optimo extends NBBaseCommand { - private final static Logger logger = LogManager.getLogger(NB_findmax.class); + private final static Logger logger = LogManager.getLogger(CMD_optimize.class); public NB_optimo(NBBufferedContainer parentComponent, String phaseName, String targetScenario) { super(parentComponent, phaseName, targetScenario); From 723aa43eaf3c75142ada6625dc6ba33f59bc9bca Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Tue, 19 Dec 2023 14:56:35 +0000 Subject: [PATCH 003/120] fix: upgrade com.amazonaws:aws-java-sdk-dynamodb from 1.12.595 to 1.12.596 Snyk has created this PR to upgrade com.amazonaws:aws-java-sdk-dynamodb from 1.12.595 to 1.12.596. See this package in Maven Repository: https://mvnrepository.com/artifact/com.amazonaws/aws-java-sdk-dynamodb/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/db3dfb82-467b-4263-94f8-28f933540a6d?utm_source=github&utm_medium=referral&page=upgrade-pr --- adapter-dynamodb/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adapter-dynamodb/pom.xml b/adapter-dynamodb/pom.xml index d064e1c0f..0c0c0b8a5 100644 --- a/adapter-dynamodb/pom.xml +++ b/adapter-dynamodb/pom.xml @@ -43,7 +43,7 @@ com.amazonaws aws-java-sdk-dynamodb - 1.12.595 + 1.12.596 From ec2d441fea523681106e91092c604bbca91eca99 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Tue, 19 Dec 2023 15:25:22 +0000 Subject: [PATCH 004/120] fix: upgrade com.github.oshi:oshi-core-java11 from 6.4.7 to 6.4.8 Snyk has created this PR to upgrade com.github.oshi:oshi-core-java11 from 6.4.7 to 6.4.8. See this package in Maven Repository: https://mvnrepository.com/artifact/com.github.oshi/oshi-core-java11/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/024e32ec-7f80-485c-b7bf-f69d45f933ce?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 384654081..650b6e74f 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -280,7 +280,7 @@ com.github.oshi oshi-core-java11 - 6.4.7 + 6.4.8 com.google.code.gson From 82c789d10b97e4deae795f93a273f549dbd86c6e Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Tue, 19 Dec 2023 15:25:25 +0000 Subject: [PATCH 005/120] fix: upgrade com.amazonaws:aws-java-sdk-s3 from 1.12.595 to 1.12.596 Snyk has created this PR to upgrade com.amazonaws:aws-java-sdk-s3 from 1.12.595 to 1.12.596. See this package in Maven Repository: https://mvnrepository.com/artifact/com.amazonaws/aws-java-sdk-s3/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/024e32ec-7f80-485c-b7bf-f69d45f933ce?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 384654081..26848ae77 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -290,7 +290,7 @@ com.amazonaws aws-java-sdk-s3 - 1.12.595 + 1.12.596 com.elega9t From 59c0cc9d8b58b42f10074af0171b6c181c24a5ce Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Tue, 19 Dec 2023 15:25:26 +0000 Subject: [PATCH 006/120] fix: upgrade org.apache.groovy:groovy from 4.0.15 to 4.0.16 Snyk has created this PR to upgrade org.apache.groovy:groovy from 4.0.15 to 4.0.16. See this package in Maven Repository: https://mvnrepository.com/artifact/org.apache.groovy/groovy/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/79ea2278-c4a8-4336-ba93-333db70b8c13?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 384654081..b5d185050 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -80,7 +80,7 @@ org.apache.groovy groovy - 4.0.15 + 4.0.16 org.snakeyaml From 9378966fd1dac6da128ee6480dd3d909bb1e8c62 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Tue, 19 Dec 2023 15:28:03 +0000 Subject: [PATCH 007/120] fix: upgrade org.apache.commons:commons-lang3 from 3.13.0 to 3.14.0 Snyk has created this PR to upgrade org.apache.commons:commons-lang3 from 3.13.0 to 3.14.0. See this package in Maven Repository: https://mvnrepository.com/artifact/org.apache.commons/commons-lang3/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/829dafa3-4836-462a-b1f4-15be99fe372a?utm_source=github&utm_medium=referral&page=upgrade-pr --- adapter-pulsar/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adapter-pulsar/pom.xml b/adapter-pulsar/pom.xml index 1ab4ab899..bc06d0b1a 100644 --- a/adapter-pulsar/pom.xml +++ b/adapter-pulsar/pom.xml @@ -61,7 +61,7 @@ org.apache.commons commons-lang3 - 3.13.0 + 3.14.0 From 3346cd26247d757e2c750a88677c9e6cca44f52b Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 19 Dec 2023 10:12:24 -0600 Subject: [PATCH 008/120] add notes for improvements --- .../engine/core/lifecycle/session/NBCommandAssembly.java | 2 ++ .../scenarios/simframe/stabilization/StabilityDetector.java | 3 +++ 2 files changed, 5 insertions(+) diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java index d1a0de12e..202538435 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBCommandAssembly.java @@ -77,6 +77,8 @@ public class NBCommandAssembly { throw new BasicError("Found zero commands for spec;" + cmd); } String containerName = cmd.getTargetContext(); + + // TODO, make this unnecessary by moving the impl out of the map to a dedicated cmd structure params.remove("_impl"); parameterizedInvocations.add(new CommandInvocation(command, params, containerName)); } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java index 356469861..631b8c598 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java @@ -155,6 +155,9 @@ public class StabilityDetector implements Runnable { } } + // TODO: Add a check for when stddev is lower than some fixed value, or when both + // (or all) windows are below some small threshold + // and perhaps add auto-correlation checks for (any of) style unblocking private void updateAndAwait() { int interval = (int) (this.timeSliceSeconds * 1000); startedAt = System.currentTimeMillis(); From 9b6838e30cb49d469f0cd9b23b8c3884de9a73c8 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Tue, 19 Dec 2023 17:05:39 +0000 Subject: [PATCH 009/120] fix: upgrade org.apache.kafka:kafka-clients from 3.6.0 to 3.6.1 Snyk has created this PR to upgrade org.apache.kafka:kafka-clients from 3.6.0 to 3.6.1. See this package in Maven Repository: https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/bb64938c-e68b-4c38-9e2f-d9d8336c07ee?utm_source=github&utm_medium=referral&page=upgrade-pr --- adapter-kafka/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adapter-kafka/pom.xml b/adapter-kafka/pom.xml index 03b4cac18..a1a8da860 100644 --- a/adapter-kafka/pom.xml +++ b/adapter-kafka/pom.xml @@ -34,7 +34,7 @@ - 3.6.0 + 3.6.1 From 9a81b816b04f09f6f4a1779e8d24a251c64582ea Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 19 Dec 2023 15:38:28 -0600 Subject: [PATCH 010/120] minor improvements to optimizers --- .../simframe/optimizers/CMD_optimize.java | 2 +- .../optimo/CMD_optimo.java} | 6 ++-- .../{ => optimizers}/optimo/NBOptimoInfo.java | 4 +-- .../optimo/OptimoFrameFunction.java | 2 +- .../optimo/OptimoFrameParams.java | 18 ++++++++-- .../optimo/OptimoParamModel.java | 2 +- .../optimo/OptimoSearchSettings.java | 2 +- .../planners/OptimizerPlannerTypes.java | 9 ++--- .../planners/findmax/FindmaxPlanner.java | 7 ++-- .../planners/ratchet/RatchetPlanner.java | 7 ++-- .../planners/rcurve/RCurveConfig.java | 12 +++---- .../planners/rcurve/RCurveFrameParams.java | 4 +++ .../planners/rcurve/RCurvePlanner.java | 33 +++++++++++++------ .../simframe/planning/HoldAndSample.java | 27 +++++++++++++++ .../simframe/planning/SimFramePlanner.java | 19 ++++++----- .../stabilization/StabilityDetector.java | 6 ++-- .../resources/examples/bindings_vectors.yaml | 2 +- 17 files changed, 110 insertions(+), 52 deletions(-) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{optimo/NB_optimo.java => optimizers/optimo/CMD_optimo.java} (97%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{ => optimizers}/optimo/NBOptimoInfo.java (91%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{ => optimizers}/optimo/OptimoFrameFunction.java (97%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{ => optimizers}/optimo/OptimoFrameParams.java (59%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{ => optimizers}/optimo/OptimoParamModel.java (97%) rename nbr/src/main/java/io/nosqlbench/scenarios/simframe/{ => optimizers}/optimo/OptimoSearchSettings.java (95%) create mode 100644 nbr/src/main/java/io/nosqlbench/scenarios/simframe/planning/HoldAndSample.java diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/CMD_optimize.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/CMD_optimize.java index 211fa32ab..3d2888fcd 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/CMD_optimize.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/CMD_optimize.java @@ -69,7 +69,7 @@ public class CMD_optimize extends NBBaseCommand { SimFrameCapture capture = new SimFrameValueData(flywheel); String plannerType = params.getOrDefault("planner", "ratchet"); OptimizerPlannerTypes plannerImpl = OptimizerPlannerTypes.valueOf(plannerType); - SimFramePlanner planner = plannerImpl.createPlanner(params); + SimFramePlanner planner = plannerImpl.createPlanner(this,params); Record result = planner.analyze(flywheel, capture, stdout, stderr, controller); stdout.println("result:\n" + result); return result; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java similarity index 97% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java index e2b6ff4ca..4777717c2 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NB_optimo.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; +package io.nosqlbench.scenarios.simframe.optimizers.optimo; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBBufferedContainer; import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; @@ -63,10 +63,10 @@ import java.util.List; * to contain a reasonably representative character of the overall manifold * */ -public class NB_optimo extends NBBaseCommand { +public class CMD_optimo extends NBBaseCommand { private final static Logger logger = LogManager.getLogger(CMD_optimize.class); - public NB_optimo(NBBufferedContainer parentComponent, String phaseName, String targetScenario) { + public CMD_optimo(NBBufferedContainer parentComponent, String phaseName, String targetScenario) { super(parentComponent, phaseName, targetScenario); } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NBOptimoInfo.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/NBOptimoInfo.java similarity index 91% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NBOptimoInfo.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/NBOptimoInfo.java index f0156a223..5297d8f49 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/NBOptimoInfo.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/NBOptimoInfo.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; +package io.nosqlbench.scenarios.simframe.optimizers.optimo; import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBBaseCommand; import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandInfo; @@ -24,6 +24,6 @@ import io.nosqlbench.nb.annotations.Service; public class NBOptimoInfo extends NBCommandInfo { @Override public Class getType() { - return NB_optimo.class; + return CMD_optimo.class; } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoFrameFunction.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoFrameFunction.java similarity index 97% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoFrameFunction.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoFrameFunction.java index df6106950..4219f4343 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoFrameFunction.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoFrameFunction.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; +package io.nosqlbench.scenarios.simframe.optimizers.optimo; import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.engine.api.activityapi.core.RunState; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoFrameParams.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoFrameParams.java similarity index 59% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoFrameParams.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoFrameParams.java index 67ca5b30e..d4534822a 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoFrameParams.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoFrameParams.java @@ -14,14 +14,18 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; +package io.nosqlbench.scenarios.simframe.optimizers.optimo; +import io.nosqlbench.engine.core.lifecycle.scenario.container.InvokableResult; +import io.nosqlbench.engine.core.lifecycle.scenario.execution.NBCommandResult; +import io.nosqlbench.nb.api.config.standard.Param; +import io.nosqlbench.scenarios.simframe.planning.GenericParamModel; + import java.util.LinkedHashMap; -import java.util.List; import java.util.Map; -public class OptimoFrameParams{ +public class OptimoFrameParams implements InvokableResult { OptimoParamModel model; double[] paramValues; @@ -40,4 +44,12 @@ public class OptimoFrameParams{ return paramValues; } + @Override + public Map asResult() { + Map result = new LinkedHashMap<>(); + for (int i = 0; i < this.paramValues.length; i++) { + result.put(model.getParams().get(i).name(),String.valueOf(paramValues[i])); + } + return result; + } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoParamModel.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java similarity index 97% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoParamModel.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java index 05cbd7f71..536696eeb 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoParamModel.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; +package io.nosqlbench.scenarios.simframe.optimizers.optimo; import io.nosqlbench.scenarios.simframe.planning.GenericParamModel; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoSearchSettings.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoSearchSettings.java similarity index 95% rename from nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoSearchSettings.java rename to nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoSearchSettings.java index eef8d0ca1..12aed639a 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimo/OptimoSearchSettings.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoSearchSettings.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.scenarios.simframe.optimo; +package io.nosqlbench.scenarios.simframe.optimizers.optimo; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; import io.nosqlbench.nb.api.engine.util.Unit; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/OptimizerPlannerTypes.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/OptimizerPlannerTypes.java index 184fdffbe..d08929573 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/OptimizerPlannerTypes.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/OptimizerPlannerTypes.java @@ -17,6 +17,7 @@ package io.nosqlbench.scenarios.simframe.optimizers.planners; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.scenarios.simframe.optimizers.planners.findmax.FindmaxPlanner; import io.nosqlbench.scenarios.simframe.optimizers.planners.ratchet.RatchetPlanner; import io.nosqlbench.scenarios.simframe.optimizers.planners.rcurve.RCurvePlanner; @@ -28,11 +29,11 @@ public enum OptimizerPlannerTypes { findmax, rcurve, ; - public SimFramePlanner createPlanner(NBCommandParams params) { + public SimFramePlanner createPlanner(NBBaseComponent parent, NBCommandParams params) { return switch (this) { - case findmax -> new FindmaxPlanner(params); - case rcurve -> new RCurvePlanner(params); - case ratchet -> new RatchetPlanner(params); + case findmax -> new FindmaxPlanner(parent, params); + case rcurve -> new RCurvePlanner(parent, params); + case ratchet -> new RatchetPlanner(parent, params); }; } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java index ed597db07..ec27fc4c0 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java @@ -20,6 +20,7 @@ import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.scenarios.simframe.capture.JournalView; import io.nosqlbench.scenarios.simframe.planning.SimFrame; @@ -30,10 +31,8 @@ import org.apache.logging.log4j.Logger; import java.util.Comparator; public class FindmaxPlanner extends SimFramePlanner { - private final Logger logger = LogManager.getLogger(FindmaxPlanner.class); - - public FindmaxPlanner(NBCommandParams analyzerParams) { - super(analyzerParams); + public FindmaxPlanner(NBBaseComponent parent, NBCommandParams analyzerParams) { + super(parent, analyzerParams); } @Override diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java index c652a93e3..8e186c7ea 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java @@ -20,6 +20,7 @@ import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.scenarios.simframe.capture.JournalView; import io.nosqlbench.scenarios.simframe.planning.SimFrame; @@ -28,10 +29,8 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; public class RatchetPlanner extends SimFramePlanner { - private final Logger logger = LogManager.getLogger(RatchetPlanner.class); - - public RatchetPlanner(NBCommandParams params) { - super(params); + public RatchetPlanner(NBBaseComponent parent, NBCommandParams params) { + super(parent, params); } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java index 62342c5af..34abc7558 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java @@ -23,20 +23,20 @@ import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; * should be reduced down to the minimum set needed. */ public record RCurveConfig( - double min_rate, - double max_rate, - int steps + double maxrate, + int maxstep, + double min_sample_seconds ) { public RCurveConfig(NBCommandParams params) { this( - params.maybeGet("min_rate").map(Double::parseDouble).orElse(0.0), params.maybeGet("max_rate").map(Double::parseDouble).orElse(10.0), - params.maybeGet("steps").map(Integer::parseInt).orElse(10) + params.maybeGet("max_step").map(Integer::parseInt).orElse(10), + params.maybeGet("min_sample_seconds").map(Double::parseDouble).orElse(10.0) ); } double rateForStep(int step) { - return min_rate + ((max_rate-min_rate)*((double)step/(double)steps)); + return ((double)step/(double) maxstep)*maxrate; } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveFrameParams.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveFrameParams.java index db0893390..23058d7b6 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveFrameParams.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveFrameParams.java @@ -19,6 +19,10 @@ package io.nosqlbench.scenarios.simframe.optimizers.planners.rcurve; public record RCurveFrameParams( double rate, int step, + int maxsteps, String description ) { + public double ratio() { + return ((double)step/(double)maxsteps); + } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java index af2868fda..f3118f5a7 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java @@ -20,28 +20,34 @@ import io.nosqlbench.engine.api.activityapi.core.Activity; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; +import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.scenarios.simframe.capture.JournalView; +import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture; +import io.nosqlbench.scenarios.simframe.planning.HoldAndSample; import io.nosqlbench.scenarios.simframe.planning.SimFrame; import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -public class RCurvePlanner extends SimFramePlanner { - private final Logger logger = LogManager.getLogger(RCurvePlanner.class); +import java.util.concurrent.locks.LockSupport; - public RCurvePlanner(NBCommandParams params) { - super(params); +public class RCurvePlanner extends SimFramePlanner implements HoldAndSample { + private RCurveFrameParams lastFrame; + + public RCurvePlanner(NBBaseComponent parent, NBCommandParams params) { + super(parent,params); + create().gauge("rcuve_step",() -> lastFrame==null ? 0 : (double)lastFrame.step()); + create().gauge("rcurve_maxstep",() -> lastFrame==null ? 0 : (double)lastFrame.maxsteps()); + create().gauge("rcurve_ratio",() -> lastFrame==null ? 0.0 : lastFrame.ratio()); + create().gauge("rcurve_rate",() -> lastFrame==null ? 0.0 : lastFrame.rate()); } - @Override public RCurveConfig getConfig(NBCommandParams params) { return new RCurveConfig(params); } public RCurveFrameParams initialStep() { - return new RCurveFrameParams(config.rateForStep(1), 1, "INITIAL"); + return new RCurveFrameParams(config.rateForStep(1), 1,config.maxstep(),"INITIAL"); } /** @@ -58,8 +64,8 @@ public class RCurvePlanner extends SimFramePlanner journal) { SimFrame last = journal.last(); int nextStep = last.params().step() +1; - if (nextStep<=config.steps()) { - return new RCurveFrameParams(config.rateForStep(nextStep),nextStep,"Advancing to step " + nextStep); + if (nextStep<=config.maxstep()) { + return new RCurveFrameParams(config.rateForStep(nextStep),nextStep,config.maxstep(),"Advancing to step " + nextStep); } else { return null; } @@ -69,4 +75,11 @@ public class RCurvePlanner extends SimFramePlanner * The configuration type for the planner */ -public abstract class SimFramePlanner { - private final Logger logger = LogManager.getLogger(SimFramePlanner.class); +public abstract class SimFramePlanner extends NBBaseComponent { + protected final Logger logger = LogManager.getLogger(SimFramePlanner.class); protected final C config; protected final SimFrameJournal

journal; - public SimFramePlanner(NBCommandParams analyzerParams) { + public SimFramePlanner(NBBaseComponent parent, NBCommandParams analyzerParams) { + super(parent, NBLabels.forKV()); this.config = getConfig(analyzerParams); this.journal = initJournal(); } @@ -69,11 +72,11 @@ public abstract class SimFramePlanner { stdout.println(frameParams); applyParams(frameParams,flywheel); capture.startWindow(); - capture.awaitSteadyState(); -// applyParams(frameParams,flywheel); -// capture.restartWindow(); -//// controller.waitMillis(500); -// capture.awaitSteadyState(); + if (this instanceof HoldAndSample has) { + has.holdAndSample(capture); + } else { + capture.awaitSteadyState(); + } capture.stopWindow(); journal.record(frameParams, capture.last()); stdout.println(capture.last()); diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java index 631b8c598..aab60d2e3 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StabilityDetector.java @@ -178,9 +178,9 @@ public class StabilityDetector implements Runnable { double value = source.getAsDouble(); apply(value); double stabilityFactor = computeStability(); -// if (Double.isNaN(stabilityFactor)) { -// System.out.println("NaN stability factor"); -// } + if (Double.isNaN(stabilityFactor)) { + throw new RuntimeException("NaN stability factor:" + this); + } if (stabilityFactor > threshold) { detectionTime = ((double) (nextCheckAt - startedAt)) / 1000d; diff --git a/nbr/src/main/resources/examples/bindings_vectors.yaml b/nbr/src/main/resources/examples/bindings_vectors.yaml index a2413470c..20798d8f4 100644 --- a/nbr/src/main/resources/examples/bindings_vectors.yaml +++ b/nbr/src/main/resources/examples/bindings_vectors.yaml @@ -21,7 +21,7 @@ bindings: # create a simple 2-d vector from a step function over the unit interval - # of 10 steps (the maximum number of characters per digit) + # of 10 maxstep (the maximum number of characters per digit) v2d: DoubleVectors('0-2*2') # use Stringify() to visualize the value of numeric array types From 74420684ee02dec66fae1c20d28d81bebb134e1f Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Wed, 20 Dec 2023 15:29:04 +0000 Subject: [PATCH 011/120] fix: upgrade org.glassfish.jersey.media:jersey-media-json-jackson from 3.1.3 to 3.1.4 Snyk has created this PR to upgrade org.glassfish.jersey.media:jersey-media-json-jackson from 3.1.3 to 3.1.4. See this package in Maven Repository: https://mvnrepository.com/artifact/org.glassfish.jersey.media/jersey-media-json-jackson/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/99d5f5ce-a2bd-4e05-9eff-86de84bd0b9e?utm_source=github&utm_medium=referral&page=upgrade-pr --- docsys/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docsys/pom.xml b/docsys/pom.xml index be1e9778a..b04a5af3c 100644 --- a/docsys/pom.xml +++ b/docsys/pom.xml @@ -94,7 +94,7 @@ org.glassfish.jersey.media jersey-media-json-jackson - 3.1.3 + 3.1.4 From dd250b37dd57dcfc4d22349b6ae84600a8ef73f0 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Wed, 20 Dec 2023 18:30:16 +0000 Subject: [PATCH 012/120] fix: upgrade org.graalvm.sdk:graal-sdk from 23.0.1 to 23.1.1 Snyk has created this PR to upgrade org.graalvm.sdk:graal-sdk from 23.0.1 to 23.1.1. See this package in Maven Repository: https://mvnrepository.com/artifact/org.graalvm.sdk/graal-sdk/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/024e32ec-7f80-485c-b7bf-f69d45f933ce?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 688644d24..f37f03142 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -361,7 +361,7 @@ org.graalvm.sdk graal-sdk - 23.0.1 + 23.1.1 org.graalvm.js From 65a2eeaa3b6836f0511335a24f8d93456979d23c Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Wed, 20 Dec 2023 18:30:20 +0000 Subject: [PATCH 013/120] fix: upgrade com.amazonaws:aws-java-sdk-s3 from 1.12.596 to 1.12.598 Snyk has created this PR to upgrade com.amazonaws:aws-java-sdk-s3 from 1.12.596 to 1.12.598. See this package in Maven Repository: https://mvnrepository.com/artifact/com.amazonaws/aws-java-sdk-s3/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/024e32ec-7f80-485c-b7bf-f69d45f933ce?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 688644d24..4332bee76 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -290,7 +290,7 @@ com.amazonaws aws-java-sdk-s3 - 1.12.596 + 1.12.598 com.elega9t From 32c4550d67273e3fce3d2eb123509cfaf2c9c908 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Wed, 20 Dec 2023 19:00:19 +0000 Subject: [PATCH 014/120] fix: upgrade org.apache.commons:commons-lang3 from 3.13.0 to 3.14.0 Snyk has created this PR to upgrade org.apache.commons:commons-lang3 from 3.13.0 to 3.14.0. See this package in Maven Repository: https://mvnrepository.com/artifact/org.apache.commons/commons-lang3/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/bb64938c-e68b-4c38-9e2f-d9d8336c07ee?utm_source=github&utm_medium=referral&page=upgrade-pr --- adapter-kafka/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adapter-kafka/pom.xml b/adapter-kafka/pom.xml index a1a8da860..6336d46f2 100644 --- a/adapter-kafka/pom.xml +++ b/adapter-kafka/pom.xml @@ -55,7 +55,7 @@ org.apache.commons commons-lang3 - 3.13.0 + 3.14.0 From d63396355a81c95b27d09ecfb0df487397055e7c Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Wed, 20 Dec 2023 19:41:37 +0000 Subject: [PATCH 015/120] fix: upgrade org.graalvm.js:js from 23.0.1 to 23.0.2 Snyk has created this PR to upgrade org.graalvm.js:js from 23.0.1 to 23.0.2. See this package in Maven Repository: https://mvnrepository.com/artifact/org.graalvm.js/js/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/6a966a50-08ee-405a-ae9a-1cfab95ff2c5?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 688644d24..8472009ce 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -366,7 +366,7 @@ org.graalvm.js js - 23.0.1 + 23.0.2 runtime From 0431c4be6e064e9e7052d0fae0e0e66abc84c7da Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:16:26 -0600 Subject: [PATCH 016/120] typo fixes --- .../simframe/optimizers/planners/rcurve/RCurveConfig.java | 6 +++--- .../simframe/optimizers/planners/rcurve/RCurvePlanner.java | 6 +++--- nbr/src/main/resources/examples/bindings_vectors.yaml | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java index 34abc7558..d403e06a9 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurveConfig.java @@ -23,8 +23,8 @@ import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; * should be reduced down to the minimum set needed. */ public record RCurveConfig( - double maxrate, - int maxstep, + double max_rate, + int max_step, double min_sample_seconds ) { public RCurveConfig(NBCommandParams params) { @@ -36,7 +36,7 @@ public record RCurveConfig( } double rateForStep(int step) { - return ((double)step/(double) maxstep)*maxrate; + return ((double)step/(double) max_step)* max_rate; } } diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java index f3118f5a7..81eed7c4a 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java @@ -47,7 +47,7 @@ public class RCurvePlanner extends SimFramePlanner journal) { SimFrame last = journal.last(); int nextStep = last.params().step() +1; - if (nextStep<=config.maxstep()) { - return new RCurveFrameParams(config.rateForStep(nextStep),nextStep,config.maxstep(),"Advancing to step " + nextStep); + if (nextStep<=config.max_step()) { + return new RCurveFrameParams(config.rateForStep(nextStep),nextStep,config.max_step(),"Advancing to step " + nextStep); } else { return null; } diff --git a/nbr/src/main/resources/examples/bindings_vectors.yaml b/nbr/src/main/resources/examples/bindings_vectors.yaml index 20798d8f4..95a034d69 100644 --- a/nbr/src/main/resources/examples/bindings_vectors.yaml +++ b/nbr/src/main/resources/examples/bindings_vectors.yaml @@ -21,7 +21,7 @@ bindings: # create a simple 2-d vector from a step function over the unit interval - # of 10 maxstep (the maximum number of characters per digit) + # of 10 max_step (the maximum number of characters per digit) v2d: DoubleVectors('0-2*2') # use Stringify() to visualize the value of numeric array types From cbc9e5484f4146c1bc1361324a1c2f0d125ed87f Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:16:28 -0600 Subject: [PATCH 017/120] remove dead code --- .../adapters/api/activityimpl/BaseOpDispenser.java | 1 - .../activityapi/core/ComponentActivityInstrumentation.java | 6 ------ .../nosqlbench/engine/api/activityimpl/motor/CoreMotor.java | 3 --- .../api/activityimpl/uniform/actions/StandardAction.java | 5 ----- 4 files changed, 15 deletions(-) diff --git a/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java b/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java index f514c240d..a171a1bdb 100644 --- a/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java +++ b/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java @@ -126,7 +126,6 @@ public abstract class BaseOpDispenser extends NBBaseComponent i Binding variables = new Binding(); Map initBlocks = op.getTemplateMap().takeAsNamedTemplates(VERIFIER_INIT); - List> verifierInitFunctions = new ArrayList<>(); try { initBlocks.forEach((initName, stringTemplate) -> { GroovyCycleFunction initFunction = diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java index c371f8109..36b26cce9 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java @@ -41,7 +41,6 @@ public class ComponentActivityInstrumentation implements ActivityInstrumentation private NBMetricTimer cyclesServiceTimer; private NBMetricTimer cyclesResponseTimer; private NBMetricCounter pendingOpsCounter; - private NBMetricCounter opTrackerBlockedCounter; private NBMetricTimer bindTimer; private NBMetricTimer executeTimer; private NBMetricTimer resultTimer; @@ -120,11 +119,6 @@ public class ComponentActivityInstrumentation implements ActivityInstrumentation return pendingOpsCounter; } - @Override - public Counter getOrCreateOpTrackerBlockedCounter() { - return opTrackerBlockedCounter; - } - @Override public Timer getOrCreateBindTimer() { return bindTimer; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java index 94a764651..82d76c614 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java @@ -75,8 +75,6 @@ public class CoreMotor implements ActivityDefObserver, Motor, Stoppable { private int stride = 1; private OpTracker opTracker; - private Counter optrackerBlockCounter; - /** * Create an ActivityMotor. @@ -194,7 +192,6 @@ public class CoreMotor implements ActivityDefObserver, Motor, Stoppable { inputTimer = activity.getInstrumentation().getOrCreateInputTimer(); strideServiceTimer = activity.getInstrumentation().getOrCreateStridesServiceTimer(); stridesResponseTimer = activity.getInstrumentation().getStridesResponseTimerOrNull(); - optrackerBlockCounter = activity.getInstrumentation().getOrCreateOpTrackerBlockedCounter(); strideRateLimiter = activity.getStrideLimiter(); cycleRateLimiter = activity.getCycleLimiter(); diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java index 3e0b2eedc..aad0e8d51 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java @@ -48,9 +48,6 @@ import java.util.concurrent.TimeUnit; */ public class StandardAction, R extends Op> implements SyncAction, ActivityDefObserver { private final static Logger logger = LogManager.getLogger("ACTION"); - - private final A activity; - private final int slot; private final Timer executeTimer; private final Histogram triesHistogram; private final Timer resultSuccessTimer; @@ -62,9 +59,7 @@ public class StandardAction, R extends Op> impl private final Timer verifierTimer; public StandardAction(A activity, int slot) { - this.activity = activity; this.opsequence = activity.getOpSequence(); - this.slot = slot; this.maxTries = activity.getMaxTries(); bindTimer = activity.getInstrumentation().getOrCreateBindTimer(); executeTimer = activity.getInstrumentation().getOrCreateExecuteTimer(); From 0c77a2fe9e233119d8d9c1850131a2481db9e335 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:16:31 -0600 Subject: [PATCH 018/120] factor client metrics checker into component attachment --- .../core/lifecycle/session/NBSession.java | 98 +------ .../session/NBSessionSafetyMetrics.java | 253 ++++++++++++++++++ 2 files changed, 255 insertions(+), 96 deletions(-) create mode 100644 engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSessionSafetyMetrics.java diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java index e7cab4a5e..0b26dc7d1 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java @@ -16,7 +16,6 @@ package io.nosqlbench.engine.core.lifecycle.session; -import io.nosqlbench.nb.api.components.core.NBComponentProps; import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef; import io.nosqlbench.nb.api.engine.metrics.instruments.NBFunctionGauge; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge; @@ -45,7 +44,7 @@ import java.util.function.Function; */ public class NBSession extends NBBaseComponent implements Function, ExecutionResult>, NBTokenWords { private final static Logger logger = LogManager.getLogger(NBSession.class); - private final ClientSystemMetricChecker clientMetricChecker; +// private final ClientSystemMetricChecker clientMetricChecker; private final Map containers = new ConcurrentHashMap<>(); @@ -64,31 +63,11 @@ public class NBSession extends NBBaseComponent implements Function, Ex labelContext.getLabels() .and("session", sessionName) ); - - this.clientMetricChecker = new ClientSystemMetricChecker(this, NBLabels.forKV(), 10); - registerLoadAvgMetrics(); - registerMemInfoMetrics(); -// registerDiskStatsMetrics(); - registerNetworkInterfaceMetrics(); - registerCpuStatMetrics(); - clientMetricChecker.start(); + new NBSessionSafetyMetrics(this); bufferOrphanedMetrics = true; } - /** - * Notes on scenario names: - *

- * - * @param cmds - * the function argument - * @return - */ public ExecutionResult apply(List cmds) { // TODO: add container closing command @@ -124,79 +103,6 @@ public class NBSession extends NBBaseComponent implements Function, Ex } - private void registerLoadAvgMetrics() { - LoadAvgReader reader = new LoadAvgReader(); - if (!reader.fileExists()) - return; - - NBFunctionGauge load1m = create().gauge("loadavg_1min", reader::getOneMinLoadAverage); - clientMetricChecker.addMetricToCheck(load1m, 50.0); - - NBFunctionGauge load5m = create().gauge("loadavg_5min", reader::getFiveMinLoadAverage); - clientMetricChecker.addMetricToCheck(load5m, 50.0); - - NBFunctionGauge load15m = create().gauge("loadavg_15min", reader::getFifteenMinLoadAverage); - clientMetricChecker.addMetricToCheck(load15m, 50.0); - // add checking for CPU load averages; TODO: Modify thresholds - - } - - private void registerMemInfoMetrics() { - MemInfoReader reader = new MemInfoReader(); - if (!reader.fileExists()) - return; - - NBMetricGauge memTotalGauge = create().gauge("mem_total", reader::getMemTotalkB); - NBMetricGauge memUsedGauge = create().gauge("mem_used", reader::getMemUsedkB); - NBMetricGauge memFreeGauge = create().gauge("mem_free", reader::getMemFreekB); - NBMetricGauge memAvailableGauge = create().gauge("mem_avaialble", reader::getMemAvailablekB); - NBMetricGauge memCachedGauge = create().gauge("mem_cache", reader::getMemCachedkB); - NBMetricGauge memBufferedGauge = create().gauge("mem_buffered", reader::getMemBufferskB); - // add checking for percent memory used at some given time; TODO: Modify percent threshold - clientMetricChecker.addRatioMetricToCheck(memUsedGauge, memTotalGauge, 90.0, false); - - NBMetricGauge swapTotalGauge = create().gauge("swap_total", reader::getSwapTotalkB); - NBMetricGauge swapFreeGauge = create().gauge("swap_free", reader::getSwapFreekB); - NBMetricGauge swapUsedGauge = create().gauge("swap_used", reader::getSwapUsedkB); - } - - private void registerDiskStatsMetrics() { - DiskStatsReader reader = new DiskStatsReader(); - if (!reader.fileExists()) - return; - - for (String device : reader.getDevices()) { - create().gauge(device + "_transactions", () -> reader.getTransactionsForDevice(device)); - create().gauge(device + "_kB_read", () -> reader.getKbReadForDevice(device)); - create().gauge(device + "_kB_written", () -> reader.getKbWrittenForDevice(device)); - } - } - - private void registerNetworkInterfaceMetrics() { - NetDevReader reader = new NetDevReader(); - if (!reader.fileExists()) - return; - for (String iface : reader.getInterfaces()) { - create().gauge(iface + "_rx_bytes", () -> reader.getBytesReceived(iface)); - create().gauge(iface + "_rx_packets", () -> reader.getPacketsReceived(iface)); - create().gauge(iface + "_tx_bytes", () -> reader.getBytesTransmitted(iface)); - create().gauge(iface + "_tx_packets", () -> reader.getPacketsTransmitted(iface)); - } - } - - private void registerCpuStatMetrics() { - StatReader reader = new StatReader(); - if (!reader.fileExists()) - return; - NBMetricGauge cpuUserGauge = create().gauge("cpu_user", reader::getUserTime); - NBMetricGauge cpuSystemGauge = create().gauge("cpu_system", reader::getSystemTime); - NBMetricGauge cpuIdleGauge = create().gauge("cpu_idle", reader::getIdleTime); - NBMetricGauge cpuIoWaitGauge = create().gauge("cpu_iowait", reader::getIoWaitTime); - NBMetricGauge cpuTotalGauge = create().gauge("cpu_total", reader::getTotalTime); - // add checking for percent of time spent in user space; TODO: Modify percent threshold - clientMetricChecker.addRatioMetricToCheck(cpuUserGauge, cpuTotalGauge, 50.0, true); - } - private NBBufferedContainer getContext(String name) { return containers.computeIfAbsent( name, diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSessionSafetyMetrics.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSessionSafetyMetrics.java new file mode 100644 index 000000000..e8a9d50c1 --- /dev/null +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSessionSafetyMetrics.java @@ -0,0 +1,253 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.engine.core.lifecycle.session; + +import io.nosqlbench.engine.core.clientload.*; +import io.nosqlbench.nb.api.components.core.NBBaseComponent; +import io.nosqlbench.nb.api.components.core.NBComponent; +import io.nosqlbench.nb.api.components.core.NBComponentMetrics; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; +import io.nosqlbench.nb.api.engine.metrics.instruments.NBFunctionGauge; +import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge; +import io.nosqlbench.nb.api.labels.NBLabels; + +public class NBSessionSafetyMetrics extends NBBaseComponent { + + public NBSessionSafetyMetrics(NBSession parent) { + super(parent, NBLabels.forKV()); + ClientSystemMetricChecker metricsChecker = registerSessionSafetyMetrics(parent); + metricsChecker.start(); + } + + private ClientSystemMetricChecker registerSessionSafetyMetrics(NBSession nbSession) { + ClientSystemMetricChecker metricsChecker = new ClientSystemMetricChecker( + this, + NBLabels.forKV(), + 10 + ); + registerLoadAvgMetrics(metricsChecker); + registerMemInfoMetrics(metricsChecker); +// registerDiskStatsMetrics(); + registerNetworkInterfaceMetrics(metricsChecker); + registerCpuStatMetrics(metricsChecker); + return metricsChecker; + } + + private void registerCpuStatMetrics(ClientSystemMetricChecker metricsChecker) { + StatReader reader = new StatReader(); + if (!reader.fileExists()) + return; + NBMetricGauge cpuUserGauge = create().gauge( + "cpu_user", + reader::getUserTime, + MetricCategory.Internals, + "" + ); + NBMetricGauge cpuSystemGauge = create().gauge( + "cpu_system", + reader::getSystemTime, + MetricCategory.Internals, + "" + ); + NBMetricGauge cpuIdleGauge = create().gauge( + "cpu_idle", + reader::getIdleTime, + MetricCategory.Internals, + "" + ); + NBMetricGauge cpuIoWaitGauge = create().gauge( + "cpu_iowait", + reader::getIoWaitTime, + MetricCategory.Internals, + "" + ); + NBMetricGauge cpuTotalGauge = create().gauge( + "cpu_total", + reader::getTotalTime, + MetricCategory.Internals, + "" + ); + // add checking for percent of time spent in user space; TODO: Modify percent threshold + metricsChecker.addRatioMetricToCheck( + cpuUserGauge, + cpuTotalGauge, + 50.0, + true + ); + } + + private void registerDiskStatsMetrics(ClientSystemMetricChecker metricsChecker) { + DiskStatsReader reader = new DiskStatsReader(); + if (!reader.fileExists()) + return; + + for (String device : reader.getDevices()) { + create().gauge( + device + "_transactions", + () -> reader.getTransactionsForDevice(device), + MetricCategory.Internals, + "" + ); + create().gauge(device + "_kB_read", + () -> reader.getKbReadForDevice(device), + MetricCategory.Internals, + "" + ); + create().gauge(device + "_kB_written", + () -> reader.getKbWrittenForDevice(device), + MetricCategory.Internals, + "" + ); + } + } + + private void registerNetworkInterfaceMetrics(ClientSystemMetricChecker metricsChecker) { + NetDevReader reader = new NetDevReader(); + if (!reader.fileExists()) + return; + for (String iface : reader.getInterfaces()) { + create().gauge( + iface + "_rx_bytes", + () -> reader.getBytesReceived(iface), + MetricCategory.Internals, + "" + ); + create().gauge( + iface + "_rx_packets", + () -> reader.getPacketsReceived(iface), + MetricCategory.Internals, + "" + ); + create().gauge( + iface + "_tx_bytes", + () -> reader.getBytesTransmitted(iface), + MetricCategory.Internals, + "" + ); + create().gauge( + iface + "_tx_packets", + () -> reader.getPacketsTransmitted(iface), + MetricCategory.Internals, + "" + ); + } + } + + private void registerLoadAvgMetrics(ClientSystemMetricChecker metricsChecker) { + LoadAvgReader reader = new LoadAvgReader(); + if (!reader.fileExists()) + return; + + NBFunctionGauge load1m = create().gauge( + "loadavg_1min", + reader::getOneMinLoadAverage, + MetricCategory.Internals, + "the 1 minute load average of the test client client" + ); + metricsChecker.addMetricToCheck(load1m, 50.0); + + NBFunctionGauge load5m = create().gauge( + "loadavg_5min", + reader::getFiveMinLoadAverage, + MetricCategory.Internals, + "the 5 minute load average of the test client client" + ); + metricsChecker.addMetricToCheck(load5m, 50.0); + + NBFunctionGauge load15m = create().gauge( + "loadavg_15min", + reader::getFifteenMinLoadAverage, + MetricCategory.Internals, + "the 15 minute load average of the test client" + ); + metricsChecker.addMetricToCheck(load15m, 50.0); + // add checking for CPU load averages; TODO: Modify thresholds + + } + + private void registerMemInfoMetrics(ClientSystemMetricChecker metricsChecker) { + MemInfoReader reader = new MemInfoReader(); + if (!reader.fileExists()) + return; + + NBMetricGauge memTotalGauge = create().gauge( + "mem_total", + reader::getMemTotalkB, + MetricCategory.Internals, + "" + + ); + NBMetricGauge memUsedGauge = create().gauge( + "mem_used", + reader::getMemUsedkB, + MetricCategory.Internals, + "" + ); + NBMetricGauge memFreeGauge = create().gauge( + "mem_free", + reader::getMemFreekB, + MetricCategory.Internals, + "" + ); + NBMetricGauge memAvailableGauge = create().gauge( + "mem_available", + reader::getMemAvailablekB, + MetricCategory.Internals, + "" + ); + NBMetricGauge memCachedGauge = create().gauge( + "mem_cache", + reader::getMemCachedkB, + MetricCategory.Internals, + "" + ); + NBMetricGauge memBufferedGauge = create().gauge( + "mem_buffered", + reader::getMemBufferskB, + MetricCategory.Internals, + "" + ); + // add checking for percent memory used at some given time; TODO: Modify percent threshold + metricsChecker.addRatioMetricToCheck( + memUsedGauge, + memTotalGauge, + 90.0, + false + ); + + NBMetricGauge swapTotalGauge = create().gauge( + "swap_total", + reader::getSwapTotalkB, + MetricCategory.Internals, + "" + ); + NBMetricGauge swapFreeGauge = create().gauge( + "swap_free", + reader::getSwapFreekB, + MetricCategory.Internals, + "" + ); + NBMetricGauge swapUsedGauge = create().gauge( + "swap_used", + reader::getSwapUsedkB, + MetricCategory.Internals, + "" + ); + } + + +} From 5db3988e22e5d3af5fcc7b56f6b57824c9685006 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:16:34 -0600 Subject: [PATCH 019/120] backfill missing metric source --- .../nosqlbench/engine/api/activityimpl/input/AtomicInput.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java index 85db5bde1..b76efd947 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java @@ -71,11 +71,11 @@ public class AtomicInput extends NBBaseComponent implements Input, ActivityDefOb } private double getTotalRecycles() { - return 0.0d; + return ((double)this.recycles_max.get())-((double)this.recycles_min.get()); } private double getTotalCycles() { - return 0.0d; + return ((double)this.cycles_max.get())-((double)this.cycles_min.get()); } @Override From b62c62314327aa52eb2a6dbd741cbfcd081c7682 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:16:37 -0600 Subject: [PATCH 020/120] add notes for later --- .../engine/api/activityimpl/uniform/actions/StandardAction.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java index aad0e8d51..f5a09523f 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/actions/StandardAction.java @@ -105,7 +105,7 @@ public class StandardAction, R extends Op> impl throw new RuntimeException("The op implementation did not implement any active logic. Implement " + "one of [RunnableOp, CycleOp, or ChainingOp]"); } - + // TODO: break out validation timer from execute try (Timer.Context ignored = verifierTimer.time()) { CycleFunction verifier = dispenser.getVerifier(); try { From 274b5b119b93a9f09c6196b5779bd45267adda4d Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:16:40 -0600 Subject: [PATCH 021/120] add docs to metrics construction --- .../adapter/amqp/util/AmqpAdapterMetrics.java | 43 +++++- .../opdispensers/Cqld4BaseOpDispenser.java | 22 ++- .../adapter/diag/optasks/DiagTask_gauge.java | 8 +- .../adapter/http/core/HttpMetrics.java | 8 +- .../kafka/util/KafkaAdapterMetrics.java | 57 ++++++-- .../pulsar/util/PulsarAdapterMetrics.java | 132 ++++++++++++++---- .../adapter/s4j/util/S4JAdapterMetrics.java | 19 ++- .../api/activityimpl/BaseOpDispenser.java | 22 ++- .../api/metrics/ThreadLocalNamedTimers.java | 8 +- .../core/ActivityInstrumentation.java | 2 - .../ComponentActivityInstrumentation.java | 84 +++++++++-- .../ratelimits/simrate/SimRate.java | 23 ++- .../api/activityimpl/input/AtomicInput.java | 57 ++++++-- .../uniform/StandardActivity.java | 19 ++- .../api/metrics/ExceptionCountMetrics.java | 13 +- ...tionExpectedResultVerificationMetrics.java | 13 +- .../api/metrics/ExceptionHistoMetrics.java | 15 +- .../api/metrics/ExceptionMeterMetrics.java | 11 +- .../api/metrics/ExceptionTimerMetrics.java | 15 +- .../lifecycle/activity/ActivityExecutor.java | 8 +- .../core/lifecycle/session/NBSession.java | 1 + .../core/NBBaseComponentMetrics.java | 3 +- .../components/core/NBComponentMetrics.java | 3 +- .../nb/api/components/core/NBCreators.java | 39 +++--- .../metrics/instruments/MetricCategory.java | 78 +++++++++++ .../metrics/wrappers/RelevancyMeasures.java | 3 +- .../AttachedMetricsSummaryReporterTest.java | 37 ++++- .../core/NBBaseComponentMetricsTest.java | 25 +++- .../core/NBComponentServicesTest.java | 15 +- .../components/core/NBMetricsQueryTest.java | 19 ++- .../planners/rcurve/RCurvePlanner.java | 28 +++- .../core/script/MetricsIntegrationTest.java | 8 +- 32 files changed, 698 insertions(+), 140 deletions(-) create mode 100644 nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java diff --git a/adapter-amqp/src/main/java/io/nosqlbench/adapter/amqp/util/AmqpAdapterMetrics.java b/adapter-amqp/src/main/java/io/nosqlbench/adapter/amqp/util/AmqpAdapterMetrics.java index c816ad18a..9f5f00a78 100644 --- a/adapter-amqp/src/main/java/io/nosqlbench/adapter/amqp/util/AmqpAdapterMetrics.java +++ b/adapter-amqp/src/main/java/io/nosqlbench/adapter/amqp/util/AmqpAdapterMetrics.java @@ -20,6 +20,7 @@ import com.codahale.metrics.Counter; import com.codahale.metrics.Histogram; import com.codahale.metrics.Timer; import io.nosqlbench.adapter.amqp.dispensers.AmqpBaseOpDispenser; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabeledElement; import io.nosqlbench.nb.api.labels.NBLabels; import org.apache.logging.log4j.LogManager; @@ -55,17 +56,45 @@ public class AmqpAdapterMetrics { public void initS4JAdapterInstrumentation() { // Histogram metrics - messageSizeHistogram = amqpBaseOpDispenser.create().histogram("message_size"); + messageSizeHistogram = amqpBaseOpDispenser.create().histogram( + "amqp_message_size", + MetricCategory.Driver, + "AMQP message size" + ); // Timer metrics - bindTimer = amqpBaseOpDispenser.create().timer("bind"); - executeTimer = amqpBaseOpDispenser.create().timer("execute"); + bindTimer = amqpBaseOpDispenser.create().timer( + "amqp_bind", + MetricCategory.Driver, + "AMQP bind timer" + ); + executeTimer = amqpBaseOpDispenser.create().timer( + "amqp_execute", + MetricCategory.Driver, + "AMQP execute timer" + ); // End-to-end metrics // Latency - e2eMsgProcLatencyHistogram = amqpBaseOpDispenser.create().histogram("e2e_msg_latency"); + e2eMsgProcLatencyHistogram = amqpBaseOpDispenser.create().histogram( + "amqp_e2e_msg_latency", + MetricCategory.Driver, + "AMQP end-to-end message processing latency" + ); // Error metrics - msgErrOutOfSeqCounter = amqpBaseOpDispenser.create().counter("err_msg_oos"); - msgErrLossCounter = amqpBaseOpDispenser.create().counter("err_msg_loss"); - msgErrDuplicateCounter = amqpBaseOpDispenser.create().counter("err_msg_dup"); + msgErrOutOfSeqCounter = amqpBaseOpDispenser.create().counter( + "amqp_err_msg_oos", + MetricCategory.Driver, + "AMQP out-of-sequence error count" + ); + msgErrLossCounter = amqpBaseOpDispenser.create().counter( + "amqp_err_msg_loss", + MetricCategory.Driver, + "AMQP lost message error count" + ); + msgErrDuplicateCounter = amqpBaseOpDispenser.create().counter( + "err_msg_dup", + MetricCategory.Driver, + "AMQP duplicate message count" + ); } public Timer getBindTimer() { return bindTimer; } diff --git a/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java b/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java index 770a0eff9..1b9e17551 100644 --- a/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java +++ b/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java @@ -31,6 +31,7 @@ import io.nosqlbench.adapters.api.activityimpl.BaseOpDispenser; import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter; import io.nosqlbench.adapters.api.templating.ParsedOp; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -57,9 +58,24 @@ public abstract class Cqld4BaseOpDispenser extends BaseOpDispenser, NBPar } logger.info("Registering gauge for diag task with labels:" + getParentLabels().getLabels() + " label:" + label); - this.gauge=parent.create().gauge(label,() -> this.sampleValue); + this.gauge=parent.create().gauge( + label, + () -> this.sampleValue, + MetricCategory.Verification, + "a diagnostic gauge for the purposes of testing " + description() + ); } @Override diff --git a/adapter-http/src/main/java/io/nosqlbench/adapter/http/core/HttpMetrics.java b/adapter-http/src/main/java/io/nosqlbench/adapter/http/core/HttpMetrics.java index 7437bda6f..8cd4a301a 100644 --- a/adapter-http/src/main/java/io/nosqlbench/adapter/http/core/HttpMetrics.java +++ b/adapter-http/src/main/java/io/nosqlbench/adapter/http/core/HttpMetrics.java @@ -17,6 +17,7 @@ package io.nosqlbench.adapter.http.core; import com.codahale.metrics.Histogram; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabeledElement; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.components.core.NBComponent; @@ -29,7 +30,12 @@ public class HttpMetrics implements NBLabeledElement { public HttpMetrics(NBComponent parent, HttpSpace space) { this.parent = parent; this.space = space; - statusCodeHistogram = parent.create().histogram("statuscode",space.getHdrDigits()); + statusCodeHistogram = parent.create().histogram( + "statuscode", + space.getHdrDigits(), + MetricCategory.Payload, + "A histogram of status codes received by the HTTP client" + ); } public String getName() { diff --git a/adapter-kafka/src/main/java/io/nosqlbench/adapter/kafka/util/KafkaAdapterMetrics.java b/adapter-kafka/src/main/java/io/nosqlbench/adapter/kafka/util/KafkaAdapterMetrics.java index 81c489a71..a3198c0aa 100644 --- a/adapter-kafka/src/main/java/io/nosqlbench/adapter/kafka/util/KafkaAdapterMetrics.java +++ b/adapter-kafka/src/main/java/io/nosqlbench/adapter/kafka/util/KafkaAdapterMetrics.java @@ -20,8 +20,10 @@ import com.codahale.metrics.Counter; import com.codahale.metrics.Histogram; import com.codahale.metrics.Timer; import io.nosqlbench.adapter.kafka.dispensers.KafkaBaseOpDispenser; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabeledElement; import io.nosqlbench.nb.api.labels.NBLabels; +import org.apache.kafka.common.Metric; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -50,37 +52,70 @@ public class KafkaAdapterMetrics { public KafkaAdapterMetrics(final KafkaBaseOpDispenser kafkaBaseOpDispenser, final NBLabeledElement labeledParent) { this.kafkaBaseOpDispenser = kafkaBaseOpDispenser; - labels=labeledParent.getLabels().and("name",KafkaAdapterMetrics.class.getSimpleName()); + labels = labeledParent.getLabels().and("name", KafkaAdapterMetrics.class.getSimpleName()); } public void initS4JAdapterInstrumentation() { // Histogram metrics - messageSizeHistogram = kafkaBaseOpDispenser.create().histogram("message_size"); + messageSizeHistogram = kafkaBaseOpDispenser.create().histogram( + "kafka_message_size", + MetricCategory.Payload, + "kafka message size" + ); // Timer metrics bindTimer = this.kafkaBaseOpDispenser.create().timer( - "bind"); + "kafka_bind", + MetricCategory.Payload, + "kafka bind timer"); executeTimer = this.kafkaBaseOpDispenser.create().timer( - "execute"); + "kafka_execute", + MetricCategory.Payload, + "kafka execute timer" + ); // End-to-end metrics // Latency e2eMsgProcLatencyHistogram = - kafkaBaseOpDispenser.create().histogram("e2e_msg_latency"); + kafkaBaseOpDispenser.create().histogram( + "e2e_msg_latency", + MetricCategory.Driver, + "End-to-end kafka message latency" + ); // Error metrics msgErrOutOfSeqCounter = - kafkaBaseOpDispenser.create().counter("err_msg_oos"); + kafkaBaseOpDispenser.create().counter( + "kafka_err_msg_oos", + MetricCategory.Driver, + "kafka Out-of-sequence errors" + ); msgErrLossCounter = - kafkaBaseOpDispenser.create().counter("err_msg_loss"); + kafkaBaseOpDispenser.create().counter( + "kafka_err_msg_loss", + MetricCategory.Driver, + "kafka message loss errors" + ); msgErrDuplicateCounter = - kafkaBaseOpDispenser.create().counter( "err_msg_dup"); + kafkaBaseOpDispenser.create().counter( + "kafka_err_msg_dup", + MetricCategory.Driver, + "kafka duplicate message errors" + ); } - public Timer getBindTimer() { return bindTimer; } - public Timer getExecuteTimer() { return executeTimer; } - public Histogram getMessagesizeHistogram() { return messageSizeHistogram; } + public Timer getBindTimer() { + return bindTimer; + } + + public Timer getExecuteTimer() { + return executeTimer; + } + + public Histogram getMessagesizeHistogram() { + return messageSizeHistogram; + } public Counter getMsgErrOutOfSeqCounter() { return msgErrOutOfSeqCounter; diff --git a/adapter-pulsar/src/main/java/io/nosqlbench/adapter/pulsar/util/PulsarAdapterMetrics.java b/adapter-pulsar/src/main/java/io/nosqlbench/adapter/pulsar/util/PulsarAdapterMetrics.java index ae7bf6fb8..1e2d04c8a 100644 --- a/adapter-pulsar/src/main/java/io/nosqlbench/adapter/pulsar/util/PulsarAdapterMetrics.java +++ b/adapter-pulsar/src/main/java/io/nosqlbench/adapter/pulsar/util/PulsarAdapterMetrics.java @@ -20,6 +20,7 @@ import com.codahale.metrics.Counter; import com.codahale.metrics.Histogram; import com.codahale.metrics.Timer; import io.nosqlbench.adapter.pulsar.dispensers.PulsarBaseOpDispenser; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.pulsar.client.api.Consumer; @@ -66,22 +67,52 @@ public class PulsarAdapterMetrics { public void initPulsarAdapterInstrumentation() { // Counter metrics msgErrOutOfSeqCounter = - pulsarBaseOpDispenser.create().counter("err_msg_oos"); + pulsarBaseOpDispenser.create().counter("pulsar_err_msg_oos", + MetricCategory.Driver, + "pulsar out-of-sequence error counter" + ); msgErrLossCounter = - pulsarBaseOpDispenser.create().counter("err_msg_loss"); + pulsarBaseOpDispenser.create().counter("pulsar_err_msg_loss", + MetricCategory.Driver, + "pulsar lost message error counter" + ); msgErrDuplicateCounter = - pulsarBaseOpDispenser.create().counter("err_msg_dup"); + pulsarBaseOpDispenser.create().counter("pulsar_err_msg_dup", + MetricCategory.Driver, + "pulsar duplicate message error counter" + ); // Histogram metrics - messageSizeHistogram = pulsarBaseOpDispenser.create().histogram("message_size"); - e2eMsgProcLatencyHistogram = pulsarBaseOpDispenser.create().histogram("e2e_msg_latency"); - payloadRttHistogram = pulsarBaseOpDispenser.create().histogram("payload_rtt"); + messageSizeHistogram = pulsarBaseOpDispenser.create().histogram("pulsar_message_size", + MetricCategory.Driver, + "pulsar message size" + ); + e2eMsgProcLatencyHistogram = pulsarBaseOpDispenser.create().histogram("pulsar_e2e_msg_latency", + MetricCategory.Driver, + "pulsar end-to-end message latency" + ); + payloadRttHistogram = pulsarBaseOpDispenser.create().histogram("pulsar_payload_rtt", + MetricCategory.Driver, + "pulsar payload round-trip-time" + ); // Timer metrics - bindTimer = pulsarBaseOpDispenser.create().timer("bind"); - executeTimer = pulsarBaseOpDispenser.create().timer("execute"); - createTransactionTimer = pulsarBaseOpDispenser.create().timer("create_transaction"); - commitTransactionTimer = pulsarBaseOpDispenser.create().timer("commit_transaction"); + bindTimer = pulsarBaseOpDispenser.create().timer("pulsar_bind", + MetricCategory.Driver, + "pulsar bind timer" + ); + executeTimer = pulsarBaseOpDispenser.create().timer("pulsar_execute", + MetricCategory.Driver, + "pulsar execution timer" + ); + createTransactionTimer = pulsarBaseOpDispenser.create().timer("pulsar_create_transaction", + MetricCategory.Driver, + "pulsar create transaction timer" + ); + commitTransactionTimer = pulsarBaseOpDispenser.create().timer("pulsar_commit_transaction", + MetricCategory.Driver, + "pulsar commit transaction timer" + ); } public Counter getMsgErrOutOfSeqCounter() { @@ -154,12 +185,36 @@ public class PulsarAdapterMetrics { public void registerProducerApiMetrics(final Producer producer) { - pulsarBaseOpDispenser.create().gauge("total_bytes_sent", PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalBytesSent() + s.getNumBytesSent())); - pulsarBaseOpDispenser.create().gauge("total_msg_sent", PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalMsgsSent() + s.getNumMsgsSent())); - pulsarBaseOpDispenser.create().gauge("total_send_failed", PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalSendFailed() + s.getNumSendFailed())); - pulsarBaseOpDispenser.create().gauge("total_ack_received", PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalAcksReceived() + s.getNumAcksReceived())); - pulsarBaseOpDispenser.create().gauge("send_bytes_rate", PulsarAdapterMetrics.producerSafeExtractMetric(producer, ProducerStats::getSendBytesRate)); - pulsarBaseOpDispenser.create().gauge("send_msg_rate", PulsarAdapterMetrics.producerSafeExtractMetric(producer, ProducerStats::getSendMsgsRate)); + pulsarBaseOpDispenser.create().gauge( + "pulsar_total_bytes_sent", + PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalBytesSent() + s.getNumBytesSent()), + MetricCategory.Driver, + "pulsar total bytes sent" + ); + pulsarBaseOpDispenser.create().gauge( + "pulsar_total_msg_sent", + PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalMsgsSent() + s.getNumMsgsSent()), + MetricCategory.Driver, + "pulsar total message sent" + ); + pulsarBaseOpDispenser.create().gauge( + "pulsar_total_send_failed", + PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalSendFailed() + s.getNumSendFailed()), + MetricCategory.Driver, + "pulsar message send failures" + ); + pulsarBaseOpDispenser.create().gauge("pulsar_total_ack_received", PulsarAdapterMetrics.producerSafeExtractMetric(producer, s -> (double) s.getTotalAcksReceived() + s.getNumAcksReceived()), + MetricCategory.Driver, + "pulsar total acknowledgements received" + ); + pulsarBaseOpDispenser.create().gauge("pulsar_send_bytes_rate", PulsarAdapterMetrics.producerSafeExtractMetric(producer, ProducerStats::getSendBytesRate), + MetricCategory.Driver, + "pulsar rate of bytes sent" + ); + pulsarBaseOpDispenser.create().gauge("pulsar_send_msg_rate", PulsarAdapterMetrics.producerSafeExtractMetric(producer, ProducerStats::getSendMsgsRate), + MetricCategory.Driver, + "pulsar rate of messages sent" + ); } @@ -193,17 +248,38 @@ public class PulsarAdapterMetrics { public void registerConsumerApiMetrics(final Consumer consumer, final String pulsarApiMetricsPrefix) { - pulsarBaseOpDispenser.create().gauge("total_bytes_recv", - PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalBytesReceived() + s.getNumBytesReceived())); - pulsarBaseOpDispenser.create().gauge("total_msg_recv", - PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalMsgsReceived() + s.getNumMsgsReceived())); - pulsarBaseOpDispenser.create().gauge("total_recv_failed", - PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalReceivedFailed() + s.getNumReceiveFailed())); - pulsarBaseOpDispenser.create().gauge("total_acks_sent", - PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalAcksSent() + s.getNumAcksSent())); - pulsarBaseOpDispenser.create().gauge("recv_bytes_rate", - PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getRateBytesReceived())); - pulsarBaseOpDispenser.create().gauge("recv_msg_rate", - PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getRateMsgsReceived())); + pulsarBaseOpDispenser.create().gauge( + "pulsar_total_bytes_recv", + PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalBytesReceived() + s.getNumBytesReceived()), + MetricCategory.Driver, + "pulsar total bytes received" + ); + pulsarBaseOpDispenser.create().gauge( + "pulsar_total_msg_recv", + PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalMsgsReceived() + s.getNumMsgsReceived()), + MetricCategory.Driver, + "pulsar total messages received" + ); + pulsarBaseOpDispenser.create().gauge( + "pulsar_total_recv_failed", + PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalReceivedFailed() + s.getNumReceiveFailed()), + MetricCategory.Driver, + "pulsar total receive failures" + ); + pulsarBaseOpDispenser.create().gauge("pulsar_total_acks_sent", + PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getTotalAcksSent() + s.getNumAcksSent()), + MetricCategory.Driver, + "pulsar total acknowledgements sent" + ); + pulsarBaseOpDispenser.create().gauge("pulsar_recv_bytes_rate", + PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getRateBytesReceived()), + MetricCategory.Driver, + "pulsar rate of bytes received" + ); + pulsarBaseOpDispenser.create().gauge("pulsar_recv_msg_rate", + PulsarAdapterMetrics.consumerSafeExtractMetric(consumer, s -> (double) s.getRateMsgsReceived()), + MetricCategory.Driver, + "pulsar rate of message received" + ); } } diff --git a/adapter-s4j/src/main/java/io/nosqlbench/adapter/s4j/util/S4JAdapterMetrics.java b/adapter-s4j/src/main/java/io/nosqlbench/adapter/s4j/util/S4JAdapterMetrics.java index cb6205be9..3b0e968a3 100644 --- a/adapter-s4j/src/main/java/io/nosqlbench/adapter/s4j/util/S4JAdapterMetrics.java +++ b/adapter-s4j/src/main/java/io/nosqlbench/adapter/s4j/util/S4JAdapterMetrics.java @@ -19,6 +19,7 @@ package io.nosqlbench.adapter.s4j.util; import com.codahale.metrics.Histogram; import com.codahale.metrics.Timer; import io.nosqlbench.adapter.s4j.dispensers.S4JBaseOpDispenser; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -38,11 +39,23 @@ public class S4JAdapterMetrics { public void initS4JAdapterInstrumentation() { // Histogram metrics - this.messageSizeHistogram = s4jBaseOpDispenser.create().histogram("message_size"); + this.messageSizeHistogram = s4jBaseOpDispenser.create().histogram( + "s4j_message_size", + MetricCategory.Driver, + "S4J message size" + ); // Timer metrics - this.bindTimer = s4jBaseOpDispenser.create().timer("bind"); - this.executeTimer = s4jBaseOpDispenser.create().timer("execute"); + this.bindTimer = s4jBaseOpDispenser.create().timer( + "s4j_bind", + MetricCategory.Driver, + "S4J bind timer" + ); + this.executeTimer = s4jBaseOpDispenser.create().timer( + "s4j_execute", + MetricCategory.Driver, + "S4j execut timer" + ); } public Timer getBindTimer() { return bindTimer; } diff --git a/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java b/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java index a171a1bdb..8ed2d3932 100644 --- a/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java +++ b/adapters-api/src/main/java/io/nosqlbench/adapters/api/activityimpl/BaseOpDispenser.java @@ -23,6 +23,7 @@ import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op; import io.nosqlbench.adapters.api.evalctx.*; import io.nosqlbench.adapters.api.metrics.ThreadLocalNamedTimers; import io.nosqlbench.adapters.api.templating.ParsedOp; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.errors.OpConfigError; import io.nosqlbench.nb.api.components.core.NBBaseComponent; @@ -99,7 +100,12 @@ public abstract class BaseOpDispenser extends NBBaseComponent i verifiers = configureVerifiers(op); this._verifier = CycleFunctions.of((a, b) -> a && b, verifiers, true); this.tlVerifier = ThreadLocal.withInitial(_verifier::newInstance); - this.verifierTimer = create().timer("verifier",3); + this.verifierTimer = create().timer( + "verifier", + 3, + MetricCategory.Verification, + "Time verifier execution, if any." + ); } private CycleFunction cloneVerifiers() { @@ -179,8 +185,18 @@ public abstract class BaseOpDispenser extends NBBaseComponent i if (this.instrument) { final int hdrDigits = pop.getStaticConfigOr("hdr_digits", 4); - successTimer = create().timer("successfor_"+getOpName(),hdrDigits); - errorTimer = create().timer("errorsfor_"+getOpName(),hdrDigits); + successTimer = create().timer( + "successfor_"+getOpName(), + hdrDigits, + MetricCategory.Core, + "Successful result timer for specific operation '" + pop.getName() + "'" + ); + errorTimer = create().timer( + "errorsfor_"+getOpName(), + hdrDigits, + MetricCategory.Core, + "Errored result timer for specific operation '" + pop.getName() + "'" + ); } } diff --git a/adapters-api/src/main/java/io/nosqlbench/adapters/api/metrics/ThreadLocalNamedTimers.java b/adapters-api/src/main/java/io/nosqlbench/adapters/api/metrics/ThreadLocalNamedTimers.java index 4051ec961..d7d3e1997 100644 --- a/adapters-api/src/main/java/io/nosqlbench/adapters/api/metrics/ThreadLocalNamedTimers.java +++ b/adapters-api/src/main/java/io/nosqlbench/adapters/api/metrics/ThreadLocalNamedTimers.java @@ -19,6 +19,7 @@ package io.nosqlbench.adapters.api.metrics; import com.codahale.metrics.Timer; import com.codahale.metrics.Timer.Context; import io.nosqlbench.adapters.api.templating.ParsedOp; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -41,7 +42,12 @@ public class ThreadLocalNamedTimers { public static void addTimer(final ParsedOp pop, final String name) { if (ThreadLocalNamedTimers.timers.containsKey("name")) ThreadLocalNamedTimers.logger.warn("A timer named '{}' was already defined and initialized.", name); - NBMetricTimer timer = pop.create().timer(name, 3); + NBMetricTimer timer = pop.create().timer( + name, + 3, + MetricCategory.User, + "User-provided metric, defined on op '" + pop.getName() + "'" + ); ThreadLocalNamedTimers.timers.put(name, timer); } diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ActivityInstrumentation.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ActivityInstrumentation.java index 4a3ce0550..4f518442c 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ActivityInstrumentation.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ActivityInstrumentation.java @@ -77,8 +77,6 @@ public interface ActivityInstrumentation { */ Counter getOrCreatePendingOpCounter(); - Counter getOrCreateOpTrackerBlockedCounter(); - /** * The bind timer keeps track of how long it takes for NoSQLBench to create an instance * of an executable operation, given the cycle. This is usually done by using an diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java index 36b26cce9..689358959 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/ComponentActivityInstrumentation.java @@ -21,6 +21,7 @@ import com.codahale.metrics.Histogram; import com.codahale.metrics.Timer; import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef; import io.nosqlbench.nb.api.engine.activityimpl.ParameterMap; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricCounter; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricHistogram; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer; @@ -57,33 +58,90 @@ public class ComponentActivityInstrumentation implements ActivityInstrumentation } private void initMetrics() { - readInputTimer=activity.create().timer("read_input",this.hdrdigits); - stridesServiceTimer=activity.create().timer("strides",this.hdrdigits); + readInputTimer=activity.create().timer( + "read_input", + this.hdrdigits, + MetricCategory.Internals, + "measures overhead of acquiring a cycle range for an activity thread" + ); + stridesServiceTimer=activity.create().timer( + "strides", + this.hdrdigits, + MetricCategory.Core, + "service timer for a stride, which is the same as the op sequence length by default" + ); if (null != activity.getStrideLimiter()) { this.stridesResponseTimer = activity.create().timer( "strides" + ComponentActivityInstrumentation.RESPONSE_TIME, - hdrdigits + hdrdigits, + MetricCategory.Core, + "response timer for a stride, which is the same as the op sequence length by default;" + + " response timers include scheduling delays which occur when an activity falls behind its target rate" ); } this.cyclesServiceTimer = activity.create().timer( "cycles"+ComponentActivityInstrumentation.SERVICE_TIME, - hdrdigits + hdrdigits, + MetricCategory.Core, + "service timer for a cycle, including all of bind, execute, result and result_success;" + + " service timers measure the time between submitting a request and receiving the response" ); if (null != activity.getCycleLimiter()) { this.cyclesResponseTimer = activity.create().timer( "cycles" + ComponentActivityInstrumentation.RESPONSE_TIME, - hdrdigits + hdrdigits, + MetricCategory.Core, + "response timer for a cycle, including all of bind, execut, result and result_success;" + + " response timers include scheduling delays which occur when an activity falls behind its target rate" ); } - this.pendingOpsCounter=activity.create().counter("pending_ops"); - this.opTrackerBlockedCounter=activity.create().counter("optracker_blocked"); + this.pendingOpsCounter=activity.create().counter( + "pending_ops", + MetricCategory.Core, + "Indicate the number of operations which have been started, but which have not been completed." + + " This starts " + ); - this.bindTimer = activity.create().timer("bind",hdrdigits); - this.executeTimer = activity.create().timer("execute",hdrdigits); - this.resultTimer = activity.create().timer("result",hdrdigits); - this.resultSuccessTimer = activity.create().timer("result_success",hdrdigits); - this.triesHistogram = activity.create().histogram("tries",hdrdigits); - this.verifierTimer = activity.create().timer("verifier",hdrdigits); + this.bindTimer = activity.create().timer( + "bind", + hdrdigits, + MetricCategory.Core, + "Time the step within a cycle which binds generated data to an op template to synthesize an executable operation." + ); + + this.executeTimer = activity.create().timer( + "execute", + hdrdigits, + MetricCategory.Core, + "Time how long it takes to submit a request and receive a result, including reading the result in the client." + ); + this.resultTimer = activity.create().timer( + "result", + hdrdigits, + MetricCategory.Core, + "Time how long it takes to submit a request, receive a result, including binding, reading results, " + + "and optionally verifying them, including all operations whether successful or not, for each attempted request." + ); + this.resultSuccessTimer = activity.create().timer( + "result_success", + hdrdigits, + MetricCategory.Core, + "The execution time of successful operations, which includes submitting the operation, waiting for a response, and reading the result" + ); + this.triesHistogram = activity.create().histogram( + "tries", + hdrdigits, + MetricCategory.Core, + "A histogram of all tries for an activity. Perfect results mean all quantiles return 1." + + " Slight saturation is indicated by p99 or p95 returning higher values." + + " Lower quantiles returning more than 1, or higher values at high quantiles indicate incremental overload." + ); + this.verifierTimer = activity.create().timer( + "verifier", + hdrdigits, + MetricCategory.Verification, + "Time the execution of verifier code, if any" + ); } diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRate.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRate.java index 646c2554c..d93430e13 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRate.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRate.java @@ -16,6 +16,7 @@ package io.nosqlbench.engine.api.activityapi.ratelimits.simrate; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.core.NBComponent; @@ -86,9 +87,25 @@ public class SimRate extends NBBaseComponent implements RateLimiter, Thread.Unca } private void initMetrics() { - create().gauge("cycles_waittime",() -> (double)getWaitTimeDuration().get(ChronoUnit.NANOS)); - create().gauge("config_cyclerate", () -> spec.opsPerSec); - create().gauge("config_burstrate", () -> spec.burstRatio); + create().gauge( + "cycles_waittime", + () -> (double)getWaitTimeDuration().get(ChronoUnit.NANOS), + MetricCategory.Core, + "The cumulative scheduling delay which accrues when" + + " an activity is not able to execute operations as fast as requested." + ); + create().gauge( + "config_cyclerate", + () -> spec.opsPerSec, + MetricCategory.Config, + "The configured cycle rate in ops/s" + ); + create().gauge( + "config_burstrate", + () -> spec.burstRatio, + MetricCategory.Config, + "the configured burst rate as a multiplier to the configured cycle rate. ex: 1.05 means 5% faster is allowed." + ); } public long refill() { diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java index b76efd947..6a7628195 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java @@ -23,6 +23,7 @@ import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.engine.api.activityapi.core.ActivityDefObserver; import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleSegment; import io.nosqlbench.engine.api.activityapi.input.Input; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -60,14 +61,54 @@ public class AtomicInput extends NBBaseComponent implements Input, ActivityDefOb super(parent); this.activityDef = activityDef; onActivityDefUpdate(activityDef); - create().gauge("input_cycles_first",() -> (double) this.cycles_min.get()); - create().gauge("input_cycles_last",() -> (double) this.cycles_max.get()); - create().gauge("input_cycle",() -> (double) this.cycle_value.get()); - create().gauge("input_cycles_total",this::getTotalCycles); - create().gauge("input_recycles_first",() -> (double) this.recycles_min.get()); - create().gauge("input_recycles_last",() -> (double) this.recycles_max.get()); - create().gauge("input_recycle",() -> (double) this.recycle_value.get()); - create().gauge("input_recycles_total",this::getTotalRecycles); + create().gauge( + "input_cycles_first", + () -> (double) this.cycles_min.get(), + MetricCategory.Config, + "The first cycle of the cycle interval, inclusive" + ); + create().gauge( + "input_cycles_last", + () -> (double) this.cycles_max.get(), + MetricCategory.Config, + "The last cycle of the cycle interval, exclusive" + ); + create().gauge( + "input_cycle", + () -> (double) this.cycle_value.get(), + MetricCategory.Core, + "The next input cycle that will be dispatched to a thread" + ); + create().gauge( + "input_cycles_total", + this::getTotalCycles, + MetricCategory.Config, + "The total number of cycles to be executed" + ); + create().gauge( + "input_recycles_first", + () -> (double) this.recycles_min.get(), + MetricCategory.Config, + "The first recycle value, inclusive" + ); + create().gauge( + "input_recycles_last", + () -> (double) this.recycles_max.get(), + MetricCategory.Config, + "The last recycle value, exclusive" + ); + create().gauge( + "input_recycle", + () -> (double) this.recycle_value.get(), + MetricCategory.Core, + "The next recycle value that will be dispatched once cycles are completed" + ); + create().gauge( + "input_recycles_total", + this::getTotalRecycles, + MetricCategory.Config, + "The total number of recycles to be executed, within which each set of cycles will be executed" + ); } private double getTotalRecycles() { diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java index 62531a882..31cadabe1 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java @@ -26,6 +26,7 @@ import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter; import io.nosqlbench.adapters.api.activityimpl.uniform.decorators.SyntheticOpTemplateProvider; import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op; import io.nosqlbench.adapters.api.templating.ParsedOp; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.lifecycle.Shutdownable; import io.nosqlbench.nb.api.components.core.NBComponent; import io.nosqlbench.nb.api.config.standard.*; @@ -155,11 +156,23 @@ public class StandardActivity extends SimpleActivity implements } create().gauge( - "ops_pending", () -> this.getProgressMeter().getSummary().pending()); + "ops_pending", + () -> this.getProgressMeter().getSummary().pending(), + MetricCategory.Core, + "The current number of operations which have not been dispatched for processing yet." + ); create().gauge( - "ops_active", () -> this.getProgressMeter().getSummary().current()); + "ops_active", + () -> this.getProgressMeter().getSummary().current(), + MetricCategory.Core, + "The current number of operations which have been dispatched for processing, but which have not yet completed." + ); create().gauge( - "ops_complete", () -> this.getProgressMeter().getSummary().complete()); + "ops_complete", + () -> this.getProgressMeter().getSummary().complete(), + MetricCategory.Core, + "The current number of operations which have been completed" + ); } @Override diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionCountMetrics.java b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionCountMetrics.java index c7cab5177..153e5d405 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionCountMetrics.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionCountMetrics.java @@ -18,6 +18,7 @@ package io.nosqlbench.engine.api.metrics; import com.codahale.metrics.Counter; import io.nosqlbench.nb.api.components.core.NBComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import java.util.ArrayList; import java.util.List; @@ -33,7 +34,11 @@ public class ExceptionCountMetrics { public ExceptionCountMetrics(final NBComponent parent) { this.parent = parent; - this.allerrors=parent.create().counter( "errors_ALL"); + this.allerrors=parent.create().counter( + "errors_ALL", + MetricCategory.Errors, + "all errors, regardless of type type, for " + parent.description() + ); } public void count(final String name) { @@ -41,7 +46,11 @@ public class ExceptionCountMetrics { if (null == c) synchronized (this.counters) { c = this.counters.computeIfAbsent( name, - k -> parent.create().counter("errors_" + name) + k -> parent.create().counter( + "errors_" + name, + MetricCategory.Errors, + name + " errors for " + parent.description() + ) ); } c.inc(); diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionExpectedResultVerificationMetrics.java b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionExpectedResultVerificationMetrics.java index ccd8b212f..2b9b1e37d 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionExpectedResultVerificationMetrics.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionExpectedResultVerificationMetrics.java @@ -18,6 +18,7 @@ package io.nosqlbench.engine.api.metrics; import com.codahale.metrics.Counter; import io.nosqlbench.nb.api.components.core.NBComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; /** @@ -30,8 +31,16 @@ public class ExceptionExpectedResultVerificationMetrics { public ExceptionExpectedResultVerificationMetrics(final NBComponent parent) { this.parent = parent; - this.verificationRetries=parent.create().counter("verificationcounts_RETRIES"); - this.verificationErrors=parent.create().counter( "verificationcounts_ERRORS"); + this.verificationRetries=parent.create().counter( + "verificationcounts_RETRIES", + MetricCategory.Verification, + "The number of retries used by the optional verifier logic for a given operation" + ); + this.verificationErrors=parent.create().counter( + "verificationcounts_ERRORS", + MetricCategory.Verification, + "The number of errors encountered while attempting to verify the result of an soperation" + ); } public void countVerificationRetries() { diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionHistoMetrics.java b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionHistoMetrics.java index 4f60bf0c0..a3baa8f5b 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionHistoMetrics.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionHistoMetrics.java @@ -19,6 +19,7 @@ package io.nosqlbench.engine.api.metrics; import com.codahale.metrics.Histogram; import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef; import io.nosqlbench.nb.api.components.core.NBComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import java.util.ArrayList; import java.util.List; @@ -38,7 +39,12 @@ public class ExceptionHistoMetrics { public ExceptionHistoMetrics(final NBComponent parent, final ActivityDef activityDef) { this.parent = parent; this.activityDef = activityDef; - this.allerrors = parent.create().histogram( "errorhistos_ALL", activityDef.getParams().getOptionalInteger("hdr_digits").orElse(4)); + this.allerrors = parent.create().histogram( + "errorhistos_ALL", + activityDef.getParams().getOptionalInteger("hdr_digits").orElse(4), + MetricCategory.Errors, + "A histogram for all exceptions" + ); } public void update(final String name, final long magnitude) { @@ -46,7 +52,12 @@ public class ExceptionHistoMetrics { if (null == h) synchronized (this.histos) { h = this.histos.computeIfAbsent( name, - errName -> parent.create().histogram( "errorhistos_"+errName, this.activityDef.getParams().getOptionalInteger("hdr_digits").orElse(4)) + errName -> parent.create().histogram( + "errorhistos_"+errName, + this.activityDef.getParams().getOptionalInteger("hdr_digits").orElse(4), + MetricCategory.Errors, + "error histogram for exception '" + errName + "'" + ) ); } h.update(magnitude); diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionMeterMetrics.java b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionMeterMetrics.java index 16186b5a1..5ab207086 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionMeterMetrics.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionMeterMetrics.java @@ -18,6 +18,7 @@ package io.nosqlbench.engine.api.metrics; import com.codahale.metrics.Meter; import io.nosqlbench.nb.api.components.core.NBComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import java.util.ArrayList; import java.util.List; @@ -33,7 +34,9 @@ public class ExceptionMeterMetrics { public ExceptionMeterMetrics(final NBComponent parent) { this.parent = parent; - this.allerrors = parent.create().meter("errormeters_ALL"); + this.allerrors = parent.create().meter("errormeters_ALL", MetricCategory.Errors, + "all errors, regardless of type type, for the parent " + parent.description() + ); } public void mark(final String name) { @@ -41,7 +44,11 @@ public class ExceptionMeterMetrics { if (null == c) synchronized (this.meters) { c = this.meters.computeIfAbsent( name, - k -> parent.create().meter("errormeters_" + name) + k -> parent.create().meter( + "errormeters_" + name, + MetricCategory.Errors, + name + " errors for " + parent.description() + ) ); } c.mark(); diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionTimerMetrics.java b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionTimerMetrics.java index 3edcd751e..0dfd79ca6 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionTimerMetrics.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/metrics/ExceptionTimerMetrics.java @@ -19,6 +19,7 @@ package io.nosqlbench.engine.api.metrics; import com.codahale.metrics.Timer; import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef; import io.nosqlbench.nb.api.components.core.NBComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import java.util.ArrayList; import java.util.List; @@ -38,14 +39,24 @@ public class ExceptionTimerMetrics { this.activityDef = activityDef; this.parentLabels = parent; - this.allerrors=parent.create().timer("errortimers_ALL",4); + this.allerrors=parent.create().timer( + "errortimers_ALL", + 4, + MetricCategory.Errors, + "exception timers for all error types" + ); } public void update(final String name, final long nanosDuration) { Timer timer = this.timers.get(name); if (null == timer) synchronized (this.timers) { timer = this.timers.computeIfAbsent( - name, k -> parentLabels.create().timer("errortimers_" + name, 3) + name, k -> parentLabels.create().timer( + "errortimers_" + name, + 3, + MetricCategory.Errors, + "exception timers for specific error '" + name + "'" + ) ); } timer.update(nanosDuration, TimeUnit.NANOSECONDS); diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/activity/ActivityExecutor.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/activity/ActivityExecutor.java index bd6e9743d..7ad32521b 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/activity/ActivityExecutor.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/activity/ActivityExecutor.java @@ -16,6 +16,7 @@ package io.nosqlbench.engine.core.lifecycle.activity; import com.codahale.metrics.Gauge; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge; import io.nosqlbench.nb.api.labels.NBLabeledElement; import io.nosqlbench.nb.api.labels.NBLabels; @@ -463,7 +464,12 @@ public class ActivityExecutor implements NBLabeledElement, ParameterMap.Listener // } private void registerMetrics() { - this.activity.create().gauge("threads",() -> (double) this.motors.size()); + this.activity.create().gauge( + "threads", + () -> (double) this.motors.size(), + MetricCategory.Core, + "The current number of threads in activity " + this.description() + ); } diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java index 0b26dc7d1..9e98c6e9f 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java @@ -17,6 +17,7 @@ package io.nosqlbench.engine.core.lifecycle.session; import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBFunctionGauge; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge; import io.nosqlbench.nb.api.labels.NBLabeledElement; diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetrics.java b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetrics.java index 48ab89a65..5576d2ffc 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetrics.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetrics.java @@ -16,6 +16,7 @@ package io.nosqlbench.nb.api.components.core; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.tagging.TagFilter; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; @@ -28,7 +29,7 @@ public class NBBaseComponentMetrics implements NBComponentMetrics { private final Lock lock = new ReentrantLock(false); private final Map metrics = new ConcurrentHashMap<>(); @Override - public String addComponentMetric(NBMetric metric) { + public String addComponentMetric(NBMetric metric, MetricCategory category, String requiredDescription) { try { lock.lock(); String openMetricsName = metric.getLabels().linearizeAsMetrics(); diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBComponentMetrics.java b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBComponentMetrics.java index 47689cbca..d4dac5844 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBComponentMetrics.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBComponentMetrics.java @@ -16,6 +16,7 @@ package io.nosqlbench.nb.api.components.core; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; import java.util.Collection; @@ -29,7 +30,7 @@ import java.util.List; * */ public interface NBComponentMetrics { - String addComponentMetric(NBMetric metric); + String addComponentMetric(NBMetric metric, MetricCategory category, String requiredDescription); /** * If you have the serialized open metrics name of a metric, you can ask for it diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java index e52502471..1e5577e98 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java @@ -53,63 +53,64 @@ public class NBCreators { this.base = base; } - public NBMetricTimer timer(String metricFamilyName) { - return timer(metricFamilyName,3); + public NBMetricTimer timer(String metricFamilyName, MetricCategory category, String description) { + return timer(metricFamilyName,3, category,description); } - public NBMetricTimer timer(String metricFamilyName, int hdrdigits) { + + public NBMetricTimer timer(String metricFamilyName, int hdrdigits, MetricCategory category, String description) { NBLabels labels = base.getLabels().and("name", metricFamilyName); NBMetricTimer timer = new NBMetricTimer(labels, new DeltaHdrHistogramReservoir(labels, hdrdigits)); - base.addComponentMetric(timer); + base.addComponentMetric(timer, category, description); return timer; } - public Meter meter(String metricFamilyName) { + public Meter meter(String metricFamilyName, MetricCategory category, String requiredDescription) { NBLabels labels = base.getLabels().and("name", metricFamilyName); NBMetricMeter meter = new NBMetricMeter(labels); - base.addComponentMetric(meter); + base.addComponentMetric(meter, category, requiredDescription); return meter; } - public NBMetricCounter counter(String metricFamilyName) { + public NBMetricCounter counter(String metricFamilyName, MetricCategory category, String requiredDescription) { NBLabels labels = base.getLabels().and("name", metricFamilyName); NBMetricCounter counter = new NBMetricCounter(labels); - base.addComponentMetric(counter); + base.addComponentMetric(counter, category, requiredDescription); return counter; } - public NBFunctionGauge gauge(String metricFamilyName, Supplier valueSource) { + public NBFunctionGauge gauge(String metricFamilyName, Supplier valueSource, MetricCategory category, String requiredDescription) { NBFunctionGauge gauge = new NBFunctionGauge(base, valueSource, metricFamilyName); - base.addComponentMetric(gauge); + base.addComponentMetric(gauge, category, requiredDescription); return gauge; } - public NBVariableGauge variableGauge(String metricFamilyName, double initialValue, String... additionalLabels) { + public NBVariableGauge variableGauge(String metricFamilyName, double initialValue, MetricCategory category, String requiredDescription, String... additionalLabels) { NBVariableGauge gauge = new NBVariableGauge(base, metricFamilyName, initialValue, additionalLabels); - base.addComponentMetric(gauge); + base.addComponentMetric(gauge, category, requiredDescription); return gauge; } - public DoubleSummaryGauge summaryGauge(String name, String... statspecs) { - List stats = Arrays.stream(statspecs).map(DoubleSummaryGauge.Stat::valueOf).toList(); + public DoubleSummaryGauge summaryGauge(String name, List statspecs, MetricCategory category, String requiredDescription) { + List stats = statspecs.stream().map(DoubleSummaryGauge.Stat::valueOf).toList(); DoubleSummaryStatistics reservoir = new DoubleSummaryStatistics(); DoubleSummaryGauge anyGauge = null; for (DoubleSummaryGauge.Stat stat : stats) { anyGauge = new DoubleSummaryGauge(base.getLabels().and(NBLabels.forKV("name",name,"stat", stat)), stat, reservoir); - base.addComponentMetric(anyGauge); + base.addComponentMetric(anyGauge, category, requiredDescription); } return anyGauge; } - public NBMetricHistogram histogram(String metricFamilyName) { - return histogram(metricFamilyName,4); + public NBMetricHistogram histogram(String metricFamilyName, MetricCategory category, String requiredDescription) { + return histogram(metricFamilyName,4, category, requiredDescription); } - public NBMetricHistogram histogram(String metricFamilyName, int hdrdigits) { + public NBMetricHistogram histogram(String metricFamilyName, int hdrdigits, MetricCategory category, String requiredDescription) { NBLabels labels = base.getLabels().and("name", metricFamilyName); NBMetricHistogram histogram = new NBMetricHistogram(labels, new DeltaHdrHistogramReservoir(labels, hdrdigits)); - base.addComponentMetric(histogram); + base.addComponentMetric(histogram, category, requiredDescription); return histogram; } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java new file mode 100644 index 000000000..683b87245 --- /dev/null +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.nb.api.engine.metrics.instruments; + +public enum MetricCategory { + /** + * Metrics which are essential to understanding the behavior of any activity + */ + Core, + /** + * Metrics which mirror configuration data, either static or dynamic during the lifetime + * of an activity, session, or container. These are shared because they may need to be known + * for further understanding or evaluation. For example, the target rate puts the achieved + * rate in context, and having them both together in downstream metrics view makes computation + * simple and direct. + */ + Config, + /** + * Metrics which are used to ascertain the validity of client behavior, such as the CPU load + * or other potentially contending effects. This is important because test results can be invalidated + * when the composed system 
{@code client <-> infrastructure <-> target system }
relies + * too heavily on the testing apparatus. When the testing apparatus is under any degree of measurable + * stress, the ability to drive the target system to its capacity is compromised, as well as the client's + * ability to approximate real-time measurements due to task scheduling delays. + */ + Internals, + /** + * When drivers are used to augment the metrics views, such as with the CQL client, these metrics can be + * folded into metrics feeds. However, they are not part of the core NB metrics. Such auxiliary metric + * need to be identified separately. + */ + Driver, + /** + * Measurements of error rates, exception counts, and any other failure modes which can be counted or + * otherwise quantified + */ + Errors, + /** + * Verification logic is used to assert the validity or some property of results returned by individual + * operations. Verification is meant to indicate whether a result was valid or invalid, with no + * room for interpretation in between. + */ + Verification, + /** + * Metrics which describe payload properties, such as result size or similar + */ + Payload, + /** + * Sometimes users provide their own metrics instrumentation. These may or may not have descriptions provided. + */ + User, + /** + * Some metrics help provide insight into analysis methods and progress. This can include parameters for + * an optimizers configuration, parameters from a single frame of simulation, achieved results in the form of + * a value function, or similar. + */ + Analysis, + /** + * When the result returned by an operation is scrutinized for some degree of accuracy on a sliding scale, + * this category applies. This is distinct from Verification in that verification implies a pass/fail scenario, + * whereas accuracy measures are on a sliding scale where interpretation is often more subjective. + */ + Accuracy +} diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/wrappers/RelevancyMeasures.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/wrappers/RelevancyMeasures.java index c0e2d4ba3..913ef2c13 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/wrappers/RelevancyMeasures.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/wrappers/RelevancyMeasures.java @@ -16,6 +16,7 @@ package io.nosqlbench.nb.api.engine.metrics.wrappers; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabeledElement; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.engine.metrics.DoubleSummaryGauge; @@ -58,7 +59,7 @@ public class RelevancyMeasures implements NBLabeledElement { for (RelevancyFunction function : f) { this.functions.add(function); function.prependLabels(this); - DoubleSummaryGauge gauge = parent.create().summaryGauge(function.getUniqueName(),DoubleSummaryGauge.Stat.Average.toString()); + DoubleSummaryGauge gauge = parent.create().summaryGauge(function.getUniqueName(), List.of("average"), MetricCategory.Accuracy, DoubleSummaryGauge.Stat.Average.toString()); this.gauges.add(gauge); } return this; diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/AttachedMetricsSummaryReporterTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/AttachedMetricsSummaryReporterTest.java index ade28a4b1..df353a304 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/AttachedMetricsSummaryReporterTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/AttachedMetricsSummaryReporterTest.java @@ -17,6 +17,7 @@ package io.nosqlbench.nb.api.components.core; import io.nosqlbench.nb.api.config.standard.TestComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBFunctionGauge; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricCounter; import org.apache.logging.log4j.LogManager; @@ -54,10 +55,22 @@ class AttachedMetricsSummaryReporterTest { TestComponent root = new TestComponent("root", "root"); scope.add(root); TestComponent l1 = new TestComponent(root, "l1", "l1"); - NBMetricCounter counter = l1.create().counter("mycounter"); + NBMetricCounter counter = l1.create().counter( + "mycounter", + MetricCategory.Verification, + "A verification metric for testing" + ); // AttachedMetricsSummaryReporter reporter = l1.create().summaryReporter(1000); - NBFunctionGauge g1 = root.create().gauge("rootgauge", () -> 42d); - NBFunctionGauge g2 = l1.create().gauge("leafgauge", () -> 48d); + NBFunctionGauge g1 = root.create().gauge( + "rootgauge", () -> 42d, + MetricCategory.Verification, + "A verification metric for testing" + ); + NBFunctionGauge g2 = l1.create().gauge( + "leafgauge", () -> 48d, + MetricCategory.Verification, + "A verification metric for testing" + ); // This wait state is here only to emulate some time passing while background processing // in the component hierarchy runs. Without it, you would be standing and immediate tearing @@ -82,10 +95,22 @@ class AttachedMetricsSummaryReporterTest { public void testAttachedReporter() { TestComponent root = new TestComponent("root", "root"); TestComponent l1 = new TestComponent(root, "l1", "l1"); - NBMetricCounter counter = l1.create().counter("mycounter"); + NBMetricCounter counter = l1.create().counter( + "mycounter", + MetricCategory.Verification, + "A verification metric for testing" + ); // AttachedMetricsSummaryReporter reporter = l1.create().summaryReporter(5000); - NBFunctionGauge g1 = root.create().gauge("rootgauge", () -> 42d); - NBFunctionGauge g2 = l1.create().gauge("leafgauge", () -> 48d); + NBFunctionGauge g1 = root.create().gauge( + "rootgauge", () -> 42d, + MetricCategory.Verification, + "A verification metric for testing" + ); + NBFunctionGauge g2 = l1.create().gauge( + "leafgauge", () -> 48d, + MetricCategory.Verification, + "A verification metric for testing" + ); // TODO: this output should also include the node itself // TODO: end lifecycle events need to be supported for metrics flushing diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java index 0c4df26ff..f7e85df73 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java @@ -17,6 +17,7 @@ package io.nosqlbench.nb.api.components.core; import io.nosqlbench.nb.api.components.core.NBBaseComponentMetrics; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBBaseMetric; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; import org.junit.jupiter.api.Test; @@ -31,9 +32,17 @@ class NBBaseComponentMetricsTest { void testBasicAddAndLookup() { NBBaseComponentMetrics cm = new NBBaseComponentMetrics(); NBMetric m1 = new NBBaseMetric("k","20"); - String m1Handle = cm.addComponentMetric(m1); + String m1Handle = cm.addComponentMetric( + m1, + MetricCategory.Verification, + "testing metric" + ); NBMetric m2 = new NBBaseMetric("k","27","l","62"); - String m2Handle = cm.addComponentMetric(m2); + String m2Handle = cm.addComponentMetric( + m2, + MetricCategory.Verification, + "testing metric" + ); assertThat(cm.getComponentMetric(m1Handle)).isEqualTo(m1); assertThat(cm.getComponentMetric(m2Handle)).isEqualTo(m2); @@ -42,9 +51,17 @@ class NBBaseComponentMetricsTest { void find() { NBBaseComponentMetrics cm = new NBBaseComponentMetrics(); NBMetric m1 = new NBBaseMetric("k","20"); - String m1Handle = cm.addComponentMetric(m1); + String m1Handle = cm.addComponentMetric( + m1, + MetricCategory.Verification, + "testing metric" + ); NBMetric m2 = new NBBaseMetric("k","27","l","62"); - String m2Handle = cm.addComponentMetric(m2); + String m2Handle = cm.addComponentMetric( + m2, + MetricCategory.Verification, + "testing metric" + ); assertThat(cm.findComponentMetrics("k=27")).isEqualTo(List.of(m2)); assertThat(cm.findComponentMetrics("k=20")).isNotEqualTo(List.of(m2)); diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBComponentServicesTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBComponentServicesTest.java index 16662e928..a00041154 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBComponentServicesTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBComponentServicesTest.java @@ -17,6 +17,7 @@ package io.nosqlbench.nb.api.components.core; import io.nosqlbench.nb.api.config.standard.TestComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBFunctionGauge; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer; @@ -35,7 +36,12 @@ class NBComponentServicesTest { TestComponent a1 = new TestComponent(root, "a1", "a1"); TestComponent b1 = new TestComponent(a1, "b1", "b1"); - NBMetricTimer timer1 = a1.create().timer("mfn1", 3); + NBMetricTimer timer1 = a1.create().timer( + "mfn1", + 3, + MetricCategory.Verification, + "testing metric" + ); String handle = timer1.getHandle(); timer1.update(23L, TimeUnit.MILLISECONDS); @@ -45,7 +51,12 @@ class NBComponentServicesTest { NBMetric foundByPattern = root.find().metric("name:mfn1"); assertThat(foundByPattern).isEqualTo(timer1); - NBFunctionGauge gauge = b1.create().gauge("test_gauge", () -> 5.2d); + NBFunctionGauge gauge = b1.create().gauge( + "test_gauge", + () -> 5.2d, + MetricCategory.Verification, + "testing metric" + ); String gaugeHandle = gauge.getHandle(); List metricsInTree = root.find().metrics(); diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java index beecdfc05..f96e366ce 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java @@ -17,6 +17,7 @@ package io.nosqlbench.nb.api.components.core; import io.nosqlbench.nb.api.config.standard.TestComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBBaseMetric; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; import org.junit.jupiter.api.Test; @@ -31,11 +32,23 @@ class NBMetricsQueryTest { private final static TestComponent root_c2 = new TestComponent(root,"c2","c2"); private final static TestComponent root_c3 = new TestComponent(root,"c3","c3"); private final static NBMetric m1 = new NBBaseMetric("m1","m1"); - private final static String m1Handle = root.addComponentMetric(m1); + private final static String m1Handle = root.addComponentMetric( + m1, + MetricCategory.Verification, + "testing metric" + ); private final static NBMetric m2 = new NBBaseMetric("m2","m2"); - private final static String m2Handle = root_c2.addComponentMetric(m2); + private final static String m2Handle = root_c2.addComponentMetric( + m2, + MetricCategory.Verification, + "testing metric" + ); private final static NBMetric m3 = new NBBaseMetric("m3","m3"); - private final static String m3Handle = root_c3.addComponentMetric(m3); + private final static String m3Handle = root_c3.addComponentMetric( + m3, + MetricCategory.Verification, + "testing metric" + ); @Test public void testFindInTree() { diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java index 81eed7c4a..9c8de4000 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java @@ -22,6 +22,7 @@ import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.events.ParamChange; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.scenarios.simframe.capture.JournalView; import io.nosqlbench.scenarios.simframe.capture.SimFrameCapture; import io.nosqlbench.scenarios.simframe.planning.HoldAndSample; @@ -35,10 +36,29 @@ public class RCurvePlanner extends SimFramePlanner lastFrame==null ? 0 : (double)lastFrame.step()); - create().gauge("rcurve_maxstep",() -> lastFrame==null ? 0 : (double)lastFrame.maxsteps()); - create().gauge("rcurve_ratio",() -> lastFrame==null ? 0.0 : lastFrame.ratio()); - create().gauge("rcurve_rate",() -> lastFrame==null ? 0.0 : lastFrame.rate()); + create().gauge( + "rcurve_step", + () -> lastFrame==null ? 0 : (double)lastFrame.step(), + MetricCategory.Analysis, + "The current step which the response curve analyzer is on" + ); + create().gauge( + "rcurve_maxstep", + () -> lastFrame==null ? 0 : (double)lastFrame.maxsteps(), + MetricCategory.Analysis, + "The maximum step that the response curve analyzer will run" + ); + create().gauge( + "rcurve_ratio", + () -> lastFrame==null ? 0.0 : lastFrame.ratio(), + MetricCategory.Analysis, + "The fractional throughput capacity of the current response curve step" + ); + create().gauge( + "rcurve_rate",() -> lastFrame==null ? 0.0 : lastFrame.rate(), + MetricCategory.Analysis, + "The actual throughput target of the current response curve step" + ); } @Override diff --git a/nbr/src/test/java/io/nosqlbench/engine/core/script/MetricsIntegrationTest.java b/nbr/src/test/java/io/nosqlbench/engine/core/script/MetricsIntegrationTest.java index 87426d9e1..09bff454b 100644 --- a/nbr/src/test/java/io/nosqlbench/engine/core/script/MetricsIntegrationTest.java +++ b/nbr/src/test/java/io/nosqlbench/engine/core/script/MetricsIntegrationTest.java @@ -19,6 +19,7 @@ package io.nosqlbench.engine.core.script; import com.codahale.metrics.Histogram; import io.nosqlbench.nb.api.config.standard.TestComponent; import io.nosqlbench.nb.api.components.core.NBComponent; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; @@ -32,7 +33,12 @@ public class MetricsIntegrationTest { @Test public void testHistogramLogger() { NBComponent parent = new TestComponent("metricstest","metricstest","alias","foo","driver","diag","op","noop"); - final Histogram testhistogram = parent.create().histogram("testhistogram", 3); + final Histogram testhistogram = parent.create().histogram( + "testhistogram", + 3, + MetricCategory.Verification, + "test metric" + ); // TODO: metrics // ActivityMetrics.addHistoLogger("testsession", ".*","testhisto.log","1s"); testhistogram.update(400); From 53b3c780bceebec0605fb7100fe31b77992d5f3e Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:16:42 -0600 Subject: [PATCH 022/120] additional work on DNN angualr1 methods --- .../shared/vectors/dnn/DNN_angular1_v.java | 55 ++++++++++++ .../vectors/dnn/DNN_angular1_vTest.java | 83 +++++++++++++++++++ 2 files changed, 138 insertions(+) create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_v.java create mode 100644 virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_vTest.java diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_v.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_v.java new file mode 100644 index 000000000..6c8296fba --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_v.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.virtdata.library.basics.shared.vectors.dnn; + +import io.nosqlbench.virtdata.api.annotations.Categories; +import io.nosqlbench.virtdata.api.annotations.Category; +import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; + +import java.util.Arrays; +import java.util.function.LongFunction; + +@ThreadSafeMapper +@Categories(Category.experimental) +public class DNN_angular1_v implements LongFunction { + + private final int d; + private final long n; + private final long m; + + /** + * @param D + * Dimensions in each vector + * @param N + * The number of vectors in the training set + * @param M + * The modulo which is used to construct equivalence classes + */ + public DNN_angular1_v(int D, long N, long M) { + d = D; + n = N; + m = M; + } + + @Override + public float[] apply(long i) { + float[] vector = new float[d]; + Arrays.fill(vector, i + 1); + vector[vector.length - 1] = (i + 1) * (i % m); + return vector; + } +} diff --git a/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_vTest.java b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_vTest.java new file mode 100644 index 000000000..10e985357 --- /dev/null +++ b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_vTest.java @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2023 nosqlbench + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.nosqlbench.virtdata.library.basics.shared.vectors.dnn; + +import org.jetbrains.annotations.TestOnly; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class DNN_angular1_vTest { + + @Test + public void testCosineSimilarity() { + assertThat(cosine_similarity(new float[]{1,2,3,4,5,6,7},new float[]{7,6,5,4,3,2,1})).isEqualTo(0.6); + assertThat(cosine_similarity(new float[]{1,2,3,4,5,6,7},new float[]{1,2,3,4,5,6,7})).isEqualTo(1.0); + } + + @Test + public void testSimpleGeneration() { + DNN_angular1_v vs = new DNN_angular1_v(2,100,3); + assertThat(vs.apply(0)).isEqualTo(new float[]{1,0}); + assertThat(vs.apply(1)).isEqualTo(new float[]{2,2}); + assertThat(vs.apply(2)).isEqualTo(new float[]{3,6}); + assertThat(vs.apply(3)).isEqualTo(new float[]{4,0}); + assertThat(vs.apply(4)).isEqualTo(new float[]{5,5}); + assertThat(vs.apply(5)).isEqualTo(new float[]{6,12}); + assertThat(vs.apply(6)).isEqualTo(new float[]{7,0}); + } + + @Test + public void testBasicAngularVectors() { + DNN_angular1_v vf = new DNN_angular1_v(10, 100, 7); + float[][] vectors = new float[100][]; + for (int i = 0; i < 100; i++) { + vectors[i] = vf.apply(i); + } + int[] same = new int[100]; + Arrays.fill(same,-1); + for (int vidx = 0; vidx < same.length; vidx++) { + for (int compare_to = 0; compare_to < vidx; compare_to++) { + if (cosine_similarity(vectors[vidx],vectors[compare_to])==1.0) { + same[vidx]=compare_to; + } + } + } + for (int sameas = 0; sameas < same.length; sameas++) { + assertThat(same[sameas]==sameas%7); + } + } + + private double cosine_similarity(float[] a, float[] b) { + double dp = 0.0d; + double as = 0.0d; + double bs = 0.0d; + for (int i = 0; i < a.length; i++) { + dp += (a[i] * b[i]); + as += (a[i] * a[i]); + bs += (b[i] * b[i]); + } + double similarity = dp / (Math.sqrt(as) * Math.sqrt(bs)); + return similarity; + } + +} From 84f9b84a6ea0cc62479e73bab9f858d72e055832 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 17:17:07 -0600 Subject: [PATCH 023/120] add docs graphic for DNN angular1 --- .../basics/shared/vectors/dnn/dnn_angular.svg | 846 ++++++++++++++++++ 1 file changed, 846 insertions(+) create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/dnn_angular.svg diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/dnn_angular.svg b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/dnn_angular.svg new file mode 100644 index 000000000..2a9cc7503 --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/dnn_angular.svg @@ -0,0 +1,846 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + d=2,m=30->(1,0)1->(2,2)2->(3,6)3->(4,0)4->(5,5)5->(6,12)6->(7,0)7->(8,8)8->(9,18)9->(10,0)10->(11,11)11->(12,24) + 0 + 1 + 2 + 4 + 5 + 3 + 6 + 9 + 10 + 7 + 8 + 11 + + + From 3f6abf12f811f4f6e55113af0238a27abf60dc9b Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 20 Dec 2023 18:12:30 -0600 Subject: [PATCH 024/120] caller updates for documented metrics --- .../api/metrics/HistoIntervalLoggerTest.java | 10 +++- .../api/metrics/NBMetricHistogramTest.java | 12 ++++- .../nb/api/components/core/NBCreators.java | 46 ++++++++++--------- .../engine/metrics/DoubleSummaryGauge.java | 21 ++++++++- .../metrics/instruments/NBBaseMetric.java | 18 +++++++- .../metrics/instruments/NBFunctionGauge.java | 33 +++++++++++-- .../engine/metrics/instruments/NBMetric.java | 3 ++ .../metrics/instruments/NBMetricCounter.java | 16 ++++++- .../instruments/NBMetricGaugeWrapper.java | 16 ++++++- .../instruments/NBMetricHistogram.java | 32 +++++++++++-- .../metrics/instruments/NBMetricMeter.java | 16 ++++++- .../metrics/instruments/NBMetricTimer.java | 23 +++++++++- .../metrics/instruments/NBVariableGauge.java | 25 +++++++++- .../core/NBBaseComponentMetricsTest.java | 9 ++-- .../components/core/NBMetricsQueryTest.java | 19 ++++++-- .../reporters/PromExpositionFormatTest.java | 40 +++++++++++++--- 16 files changed, 285 insertions(+), 54 deletions(-) diff --git a/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/HistoIntervalLoggerTest.java b/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/HistoIntervalLoggerTest.java index b97187cdd..637fc2804 100644 --- a/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/HistoIntervalLoggerTest.java +++ b/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/HistoIntervalLoggerTest.java @@ -16,6 +16,7 @@ package io.nosqlbench.engine.api.metrics; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.engine.metrics.DeltaHdrHistogramReservoir; import io.nosqlbench.nb.api.engine.metrics.HistoIntervalLogger; @@ -47,7 +48,14 @@ public class HistoIntervalLoggerTest { final int significantDigits = 4; NBMetricHistogram NBHistogram = new NBMetricHistogram( - NBLabels.forKV("name", "histo1"), new DeltaHdrHistogramReservoir(NBLabels.forKV("name", "histo1"), significantDigits)); + NBLabels.forKV("name", "histo1"), + new DeltaHdrHistogramReservoir( + NBLabels.forKV("name", "histo1"), + significantDigits + ), + "test basic logger", + MetricCategory.Verification + ); hil.onHistogramAdded("histo1", NBHistogram); diff --git a/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/NBMetricHistogramTest.java b/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/NBMetricHistogramTest.java index ca70e5c07..5327f136f 100644 --- a/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/NBMetricHistogramTest.java +++ b/engine-core/src/test/java/io/nosqlbench/engine/api/metrics/NBMetricHistogramTest.java @@ -16,6 +16,7 @@ package io.nosqlbench.engine.api.metrics; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.engine.metrics.ConvenientSnapshot; import io.nosqlbench.nb.api.engine.metrics.DeltaHdrHistogramReservoir; @@ -28,8 +29,15 @@ public class NBMetricHistogramTest { @Test public void testNicerHistogramValues() { - NBMetricHistogram nh = new NBMetricHistogram(NBLabels.forKV("name","testhisto"), new DeltaHdrHistogramReservoir( - NBLabels.forKV("name", "testhisto"), 4)); + NBMetricHistogram nh = new NBMetricHistogram( + NBLabels.forKV("name","testhisto"), + new DeltaHdrHistogramReservoir( + NBLabels.forKV("name", "testhisto"), + 4 + ), + "test nicer histogram values", + MetricCategory.Verification + ); for (int i = 1; 100 >= i; i++) { nh.update(i); } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java index 1e5577e98..1723ce2c7 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/components/core/NBCreators.java @@ -59,58 +59,62 @@ public class NBCreators { public NBMetricTimer timer(String metricFamilyName, int hdrdigits, MetricCategory category, String description) { NBLabels labels = base.getLabels().and("name", metricFamilyName); - NBMetricTimer timer = new NBMetricTimer(labels, new DeltaHdrHistogramReservoir(labels, hdrdigits)); + NBMetricTimer timer = new NBMetricTimer( + labels, + new DeltaHdrHistogramReservoir(labels, hdrdigits), + description, category + ); base.addComponentMetric(timer, category, description); return timer; } - public Meter meter(String metricFamilyName, MetricCategory category, String requiredDescription) { + public Meter meter(String metricFamilyName, MetricCategory category, String description) { NBLabels labels = base.getLabels().and("name", metricFamilyName); - NBMetricMeter meter = new NBMetricMeter(labels); - base.addComponentMetric(meter, category, requiredDescription); + NBMetricMeter meter = new NBMetricMeter(labels,description, category); + base.addComponentMetric(meter, category, description); return meter; } - public NBMetricCounter counter(String metricFamilyName, MetricCategory category, String requiredDescription) { + public NBMetricCounter counter(String metricFamilyName, MetricCategory category, String description) { NBLabels labels = base.getLabels().and("name", metricFamilyName); - NBMetricCounter counter = new NBMetricCounter(labels); - base.addComponentMetric(counter, category, requiredDescription); + NBMetricCounter counter = new NBMetricCounter(labels, description, category); + base.addComponentMetric(counter, category, description); return counter; } - public NBFunctionGauge gauge(String metricFamilyName, Supplier valueSource, MetricCategory category, String requiredDescription) { - NBFunctionGauge gauge = new NBFunctionGauge(base, valueSource, metricFamilyName); - base.addComponentMetric(gauge, category, requiredDescription); + public NBFunctionGauge gauge(String metricFamilyName, Supplier valueSource, MetricCategory category, String description) { + NBFunctionGauge gauge = new NBFunctionGauge(base, valueSource, metricFamilyName, description, category); + base.addComponentMetric(gauge, category, description); return gauge; } - public NBVariableGauge variableGauge(String metricFamilyName, double initialValue, MetricCategory category, String requiredDescription, String... additionalLabels) { - NBVariableGauge gauge = new NBVariableGauge(base, metricFamilyName, initialValue, additionalLabels); - base.addComponentMetric(gauge, category, requiredDescription); + public NBVariableGauge variableGauge(String metricFamilyName, double initialValue, MetricCategory category, String description, NBLabels additionalLabels) { + NBVariableGauge gauge = new NBVariableGauge(base, metricFamilyName, initialValue, additionalLabels, description, category); + base.addComponentMetric(gauge, category, description); return gauge; } - public DoubleSummaryGauge summaryGauge(String name, List statspecs, MetricCategory category, String requiredDescription) { + public DoubleSummaryGauge summaryGauge(String name, List statspecs, MetricCategory category, String description) { List stats = statspecs.stream().map(DoubleSummaryGauge.Stat::valueOf).toList(); DoubleSummaryStatistics reservoir = new DoubleSummaryStatistics(); DoubleSummaryGauge anyGauge = null; for (DoubleSummaryGauge.Stat stat : stats) { - anyGauge = new DoubleSummaryGauge(base.getLabels().and(NBLabels.forKV("name",name,"stat", stat)), stat, reservoir); - base.addComponentMetric(anyGauge, category, requiredDescription); + anyGauge = new DoubleSummaryGauge(base.getLabels().and(NBLabels.forKV("name",name,"stat", stat)), stat, reservoir, description, category); + base.addComponentMetric(anyGauge, category, description); } return anyGauge; } - public NBMetricHistogram histogram(String metricFamilyName, MetricCategory category, String requiredDescription) { - return histogram(metricFamilyName,4, category, requiredDescription); + public NBMetricHistogram histogram(String metricFamilyName, MetricCategory category, String description) { + return histogram(metricFamilyName,4, category, description); } - public NBMetricHistogram histogram(String metricFamilyName, int hdrdigits, MetricCategory category, String requiredDescription) { + public NBMetricHistogram histogram(String metricFamilyName, int hdrdigits, MetricCategory category, String description) { NBLabels labels = base.getLabels().and("name", metricFamilyName); - NBMetricHistogram histogram = new NBMetricHistogram(labels, new DeltaHdrHistogramReservoir(labels, hdrdigits)); - base.addComponentMetric(histogram, category, requiredDescription); + NBMetricHistogram histogram = new NBMetricHistogram(labels, new DeltaHdrHistogramReservoir(labels, hdrdigits), description, category); + base.addComponentMetric(histogram, category, description); return histogram; } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/DoubleSummaryGauge.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/DoubleSummaryGauge.java index 5d880913d..86ae33a0e 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/DoubleSummaryGauge.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/DoubleSummaryGauge.java @@ -16,6 +16,7 @@ package io.nosqlbench.nb.api.engine.metrics; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricGauge; @@ -30,12 +31,24 @@ public class DoubleSummaryGauge implements NBMetricGauge, DoubleConsumer { private final NBLabels labels; private final Stat stat; private final DoubleSummaryStatistics stats; + private final String description; + private final MetricCategory[] categories; @Override public String typeName() { return "gauge"; } + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } + public enum Stat { Min, Max, @@ -44,16 +57,20 @@ public class DoubleSummaryGauge implements NBMetricGauge, DoubleConsumer { Sum } - public DoubleSummaryGauge(NBLabels labels, Stat stat, DoubleSummaryStatistics stats) { + public DoubleSummaryGauge(NBLabels labels, Stat stat, DoubleSummaryStatistics stats, String description, MetricCategory... categories) { this.labels = labels; this.stat = stat; this.stats = stats; + this.description = description; + this.categories = categories; } - public DoubleSummaryGauge(NBLabels labels, Stat stat) { + public DoubleSummaryGauge(NBLabels labels, Stat stat,String description, MetricCategory... categories) { this.labels = labels; this.stat = stat; this.stats = new DoubleSummaryStatistics(); + this.description = description; + this.categories = categories; } public synchronized void accept(double value) { diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBBaseMetric.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBBaseMetric.java index 35504cae4..2bcf6872d 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBBaseMetric.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBBaseMetric.java @@ -20,9 +20,13 @@ import io.nosqlbench.nb.api.labels.NBLabels; public class NBBaseMetric implements NBMetric { private final NBLabels labels; + private String description; + private MetricCategory[] categories; - public NBBaseMetric(String... labels) { - this.labels = NBLabels.forKV((Object[]) labels); + public NBBaseMetric(NBLabels labels, String description, MetricCategory... categories) { + this.labels = labels; + this.description = description; + this.categories = categories; } @Override public NBLabels getLabels() { @@ -33,4 +37,14 @@ public class NBBaseMetric implements NBMetric { public String typeName() { return "basetype"; } + + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBFunctionGauge.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBFunctionGauge.java index 5e9b14300..9b2956a18 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBFunctionGauge.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBFunctionGauge.java @@ -28,14 +28,31 @@ public class NBFunctionGauge implements NBMetricGauge { private final Supplier source; private final NBLabeledElement parent; private final NBLabels labels; + private String description; + private MetricCategory[] categories; - public NBFunctionGauge(NBComponent parent, Supplier source, String metricFamilyName, Map additionalLabels) { + public NBFunctionGauge( + NBComponent parent, + Supplier source, + String metricFamilyName, + Map additionalLabels, + String description, + MetricCategory... categories + ) { this.parent = parent; this.labels = NBLabels.forMap(additionalLabels).and("name",metricFamilyName); this.source = source; + this.description = description; + this.categories = categories; } - public NBFunctionGauge(NBComponent parent, Supplier source, String metricFamilyName) { - this(parent, source, metricFamilyName,Map.of()); + public NBFunctionGauge( + NBComponent parent, + Supplier source, + String metricFamilyName, + String description, + MetricCategory... categories + ) { + this(parent, source, metricFamilyName,Map.of(), description, categories); } @Override public Double getValue() { @@ -56,6 +73,16 @@ public class NBFunctionGauge implements NBMetricGauge { public String typeName() { return "gauge"; } + + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetric.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetric.java index b65bc8402..7a18b0047 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetric.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetric.java @@ -24,4 +24,7 @@ public interface NBMetric extends Metric, NBLabeledElement { return this.getLabels().linearizeAsMetrics(); } String typeName(); + + String getDescription(); + MetricCategory[] getCategories(); } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricCounter.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricCounter.java index 3a5d901ae..a6afb8992 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricCounter.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricCounter.java @@ -22,9 +22,13 @@ import io.nosqlbench.nb.api.labels.NBLabels; public class NBMetricCounter extends Counter implements NBMetric { private final NBLabels labels; + private String description; + private MetricCategory[] categories; - public NBMetricCounter(final NBLabels labels) { + public NBMetricCounter(final NBLabels labels, String description, MetricCategory... categories) { this.labels = labels; + this.description = description; + this.categories = categories; } @Override @@ -37,6 +41,16 @@ public class NBMetricCounter extends Counter implements NBMetric { return "counter"; } + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } + @Override public String toString() { return description(); diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricGaugeWrapper.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricGaugeWrapper.java index 2323d4001..03eeb0533 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricGaugeWrapper.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricGaugeWrapper.java @@ -23,14 +23,18 @@ public class NBMetricGaugeWrapper implements NBMetricGauge, NBMetric { private final Gauge gauge; private final NBLabels labels; + private final String description; + private final MetricCategory[] categories; - public NBMetricGaugeWrapper(NBLabels labels, Gauge gauge) { + public NBMetricGaugeWrapper(NBLabels labels, Gauge gauge, String description, MetricCategory... categories) { this.gauge = gauge; if (gauge.getValue() instanceof Double d) { } else { throw new RuntimeException("NBMetricGauges only support Double values"); } this.labels = labels; + this.description = description; + this.categories = categories; } @Override @@ -47,4 +51,14 @@ public class NBMetricGaugeWrapper implements NBMetricGauge, NBMetric { public String typeName() { return "gauge"; } + + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricHistogram.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricHistogram.java index 9d5b2aea7..24ee07091 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricHistogram.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricHistogram.java @@ -31,17 +31,33 @@ public class NBMetricHistogram extends Histogram implements DeltaSnapshotter, Hd private long cacheExpiryMillis; private long cacheTimeMillis; private List mirrors; + private MetricCategory[] categories; + private String description; - public NBMetricHistogram(NBLabels labels, DeltaHdrHistogramReservoir hdrHistogramReservoir) { + public NBMetricHistogram( + NBLabels labels, + DeltaHdrHistogramReservoir hdrHistogramReservoir, + String description, + MetricCategory... categories + ) { super(hdrHistogramReservoir); this.labels = labels; this.hdrDeltaReservoir = hdrHistogramReservoir; + this.description = description; + this.categories = categories; } - public NBMetricHistogram(String name, DeltaHdrHistogramReservoir hdrHistogramReservoir) { + public NBMetricHistogram( + String name, + DeltaHdrHistogramReservoir hdrHistogramReservoir, + String description, + MetricCategory... categories + ) { super(hdrHistogramReservoir); this.labels = NBLabels.forKV("name",name); this.hdrDeltaReservoir = hdrHistogramReservoir; + this.description = description; + this.categories = categories; } @Override @@ -76,7 +92,7 @@ public class NBMetricHistogram extends Histogram implements DeltaSnapshotter, Hd mirrors = new CopyOnWriteArrayList<>(); } DeltaHdrHistogramReservoir mirrorReservoir = this.hdrDeltaReservoir.copySettings(); - NBMetricHistogram mirror = new NBMetricHistogram("mirror-" + this.labels.linearizeValues("name"), mirrorReservoir); + NBMetricHistogram mirror = new NBMetricHistogram("mirror-" + this.labels.linearizeValues("name"), mirrorReservoir, description, categories); mirrors.add(mirror); return mirror; } @@ -115,6 +131,16 @@ public class NBMetricHistogram extends Histogram implements DeltaSnapshotter, Hd return "histogram"; } + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } + @Override public String toString() { return description(); diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricMeter.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricMeter.java index 80c134c7c..c574e9f1c 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricMeter.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricMeter.java @@ -22,9 +22,13 @@ import io.nosqlbench.nb.api.labels.NBLabels; public class NBMetricMeter extends Meter implements NBMetric { private final NBLabels labels; + private final MetricCategory[] categories; + private final String description; - public NBMetricMeter(NBLabels labels) { + public NBMetricMeter(NBLabels labels, String description, MetricCategory... categories) { this.labels = labels; + this.description = description; + this.categories = categories; } @Override @@ -36,4 +40,14 @@ public class NBMetricMeter extends Meter implements NBMetric { public String typeName() { return "meter"; } + + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricTimer.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricTimer.java index 181fe73f4..33a1c3177 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricTimer.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBMetricTimer.java @@ -28,12 +28,21 @@ import java.util.concurrent.TimeUnit; public class NBMetricTimer extends Timer implements DeltaSnapshotter, HdrDeltaHistogramAttachment, TimerAttachment, NBMetric { private final DeltaHdrHistogramReservoir deltaHdrHistogramReservoir; + private final String description; + private final MetricCategory[] categories; private long cacheExpiry; private List mirrors; private final NBLabels labels; - public NBMetricTimer(final NBLabels labels, final DeltaHdrHistogramReservoir deltaHdrHistogramReservoir) { + public NBMetricTimer( + final NBLabels labels, + final DeltaHdrHistogramReservoir deltaHdrHistogramReservoir, + String description, + MetricCategory... categories + ) { super(deltaHdrHistogramReservoir); + this.description = description; + this.categories = categories; this.labels = labels; this.deltaHdrHistogramReservoir = deltaHdrHistogramReservoir; } @@ -60,7 +69,7 @@ public class NBMetricTimer extends Timer implements DeltaSnapshotter, HdrDeltaHi public synchronized NBMetricTimer attachHdrDeltaHistogram() { if (null == mirrors) this.mirrors = new CopyOnWriteArrayList<>(); final DeltaHdrHistogramReservoir sameConfigReservoir = deltaHdrHistogramReservoir.copySettings(); - final NBMetricTimer mirror = new NBMetricTimer(labels, sameConfigReservoir); + final NBMetricTimer mirror = new NBMetricTimer(labels, sameConfigReservoir, description, categories); this.mirrors.add(mirror); return mirror; } @@ -96,4 +105,14 @@ public class NBMetricTimer extends Timer implements DeltaSnapshotter, HdrDeltaHi public String typeName() { return "timer"; } + + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } } diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBVariableGauge.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBVariableGauge.java index 94c7d498d..daa20d758 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBVariableGauge.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/NBVariableGauge.java @@ -28,11 +28,22 @@ public class NBVariableGauge implements NBMetricGauge { private double value; private final NBLabeledElement parent; private final NBLabels labels; + private String description; + private MetricCategory[] categories; - public NBVariableGauge(NBComponent parent, String metricFamilyName, double initialValue, String... additionalLabels) { + public NBVariableGauge( + NBComponent parent, + String metricFamilyName, + double initialValue, + NBLabels additionalLabels, + String description, + MetricCategory... categories + ) { this.parent = parent; - this.labels = NBLabels.forKV((Object[]) additionalLabels).and("name", metricFamilyName); + this.labels = additionalLabels.and("name", metricFamilyName); this.value = initialValue; + this.description = description; + this.categories = categories; } @@ -50,4 +61,14 @@ public class NBVariableGauge implements NBMetricGauge { public String typeName() { return "gauge"; } + + @Override + public String getDescription() { + return this.description; + } + + @Override + public MetricCategory[] getCategories() { + return this.categories; + } } diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java index f7e85df73..668cd1e53 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBBaseComponentMetricsTest.java @@ -20,6 +20,7 @@ import io.nosqlbench.nb.api.components.core.NBBaseComponentMetrics; import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBBaseMetric; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; +import io.nosqlbench.nb.api.labels.NBLabels; import org.junit.jupiter.api.Test; import java.util.List; @@ -31,13 +32,13 @@ class NBBaseComponentMetricsTest { @Test void testBasicAddAndLookup() { NBBaseComponentMetrics cm = new NBBaseComponentMetrics(); - NBMetric m1 = new NBBaseMetric("k","20"); + NBMetric m1 = new NBBaseMetric(NBLabels.forKV("k","20"),"test metric", MetricCategory.Verification); String m1Handle = cm.addComponentMetric( m1, MetricCategory.Verification, "testing metric" ); - NBMetric m2 = new NBBaseMetric("k","27","l","62"); + NBMetric m2 = new NBBaseMetric(NBLabels.forKV("k","27","l","62"),"test metric", MetricCategory.Verification); String m2Handle = cm.addComponentMetric( m2, MetricCategory.Verification, @@ -50,13 +51,13 @@ class NBBaseComponentMetricsTest { @Test void find() { NBBaseComponentMetrics cm = new NBBaseComponentMetrics(); - NBMetric m1 = new NBBaseMetric("k","20"); + NBMetric m1 = new NBBaseMetric(NBLabels.forKV("k","20"),"test metric", MetricCategory.Verification); String m1Handle = cm.addComponentMetric( m1, MetricCategory.Verification, "testing metric" ); - NBMetric m2 = new NBBaseMetric("k","27","l","62"); + NBMetric m2 = new NBBaseMetric(NBLabels.forKV("k","27","l","62"),"test metric", MetricCategory.Verification); String m2Handle = cm.addComponentMetric( m2, MetricCategory.Verification, diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java index f96e366ce..f3b37038f 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/components/core/NBMetricsQueryTest.java @@ -20,6 +20,7 @@ import io.nosqlbench.nb.api.config.standard.TestComponent; import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.engine.metrics.instruments.NBBaseMetric; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; +import io.nosqlbench.nb.api.labels.NBLabels; import org.junit.jupiter.api.Test; import java.util.List; @@ -31,19 +32,31 @@ class NBMetricsQueryTest { private final static TestComponent root = new TestComponent("root","root","type","rootelement"); private final static TestComponent root_c2 = new TestComponent(root,"c2","c2"); private final static TestComponent root_c3 = new TestComponent(root,"c3","c3"); - private final static NBMetric m1 = new NBBaseMetric("m1","m1"); + private final static NBMetric m1 = new NBBaseMetric( + NBLabels.forKV("m1", "m1"), + "test metric", + MetricCategory.Verification + ); private final static String m1Handle = root.addComponentMetric( m1, MetricCategory.Verification, "testing metric" ); - private final static NBMetric m2 = new NBBaseMetric("m2","m2"); + private final static NBMetric m2 = new NBBaseMetric( + NBLabels.forKV("m2", "m2"), + "test metric", + MetricCategory.Verification + ); private final static String m2Handle = root_c2.addComponentMetric( m2, MetricCategory.Verification, "testing metric" ); - private final static NBMetric m3 = new NBBaseMetric("m3","m3"); + private final static NBMetric m3 = new NBBaseMetric( + NBLabels.forKV("m3", "m3"), + "test metric", + MetricCategory.Verification + ); private final static String m3Handle = root_c3.addComponentMetric( m3, MetricCategory.Verification, diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java index 84720339f..674d2aab9 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java @@ -46,7 +46,11 @@ public class PromExpositionFormatTest { } @Test public void testCounterFormat() { - Counter counter = new NBMetricCounter(NBLabels.forKV("name","counter_test_2342", "origin","mars")); + Counter counter = new NBMetricCounter( + NBLabels.forKV("name","counter_test_2342", "origin","mars"), + "test counter format", + MetricCategory.Verification + ); counter.inc(23423L); String buffer = PromExpositionFormat.format(nowclock, counter); @@ -64,7 +68,12 @@ public class PromExpositionFormatTest { for (long i = 0; 1000 > i; i++) { hdr.update(i * 37L); } - NBMetricHistogram nbHistogram = new NBMetricHistogram(NBLabels.forKV("name","mynameismud","label3", "value3"), hdr); + NBMetricHistogram nbHistogram = new NBMetricHistogram( + NBLabels.forKV("name","mynameismud","label3", "value3"), + hdr, + "test histogram format", + MetricCategory.Verification + ); String formatted = PromExpositionFormat.format(nowclock, nbHistogram); assertThat(formatted).matches(Pattern.compile(""" @@ -95,7 +104,12 @@ public class PromExpositionFormatTest { public void testTimerFormat() { DeltaHdrHistogramReservoir hdr = new DeltaHdrHistogramReservoir(NBLabels.forKV("name","monsieurmarius","label4","value4"),3); - NBMetricTimer nbMetricTimer = new NBMetricTimer(NBLabels.forKV("name","monsieurmarius","label4", "value4"), hdr); + NBMetricTimer nbMetricTimer = new NBMetricTimer( + NBLabels.forKV("name","monsieurmarius","label4", "value4"), + hdr, + "test timer format", + MetricCategory.Verification + ); for (long i = 0; 1000 > i; i++) nbMetricTimer.update(i * 37L, TimeUnit.NANOSECONDS); @@ -135,7 +149,11 @@ public class PromExpositionFormatTest { @Test public void testMeterFormat() { - NBMetricMeter nbMetricMeter = new NBMetricMeter(NBLabels.forKV("name","eponine","label5", "value5")); + NBMetricMeter nbMetricMeter = new NBMetricMeter( + NBLabels.forKV("name","eponine","label5", "value5"), + "test meter format", + MetricCategory.Verification + ); String formatted = PromExpositionFormat.format(nowclock, nbMetricMeter); assertThat(formatted).matches(Pattern.compile(""" @@ -155,7 +173,12 @@ public class PromExpositionFormatTest { @Test public void testGaugeFormat() { Gauge cosetteGauge = () -> 1500d; - NBMetricGauge nbMetricGauge = new NBMetricGaugeWrapper(NBLabels.forKV("name","cosette","label6", "value6"), cosetteGauge); + NBMetricGauge nbMetricGauge = new NBMetricGaugeWrapper( + NBLabels.forKV("name","cosette","label6", "value6"), + cosetteGauge, + "test gauge format", + MetricCategory.Verification + ); String formatted = PromExpositionFormat.format(nowclock, nbMetricGauge); assertThat(formatted).matches(Pattern.compile(""" @@ -164,7 +187,12 @@ public class PromExpositionFormatTest { """)); Gauge cosetteGauge2 = () -> 2000.0d; - NBMetricGauge nbMetricGauge2 = new NBMetricGaugeWrapper(NBLabels.forKV("name","cosette2","label7", "value7"), cosetteGauge2); + NBMetricGauge nbMetricGauge2 = new NBMetricGaugeWrapper( + NBLabels.forKV("name","cosette2","label7", "value7"), + cosetteGauge2, + "test gauge format 2", + MetricCategory.Verification + ); String formatted2 = PromExpositionFormat.format(nowclock, nbMetricGauge2); assertThat(formatted2).matches(Pattern.compile(""" From e3eb6ebe13c314e94f085491a32068ebc86ab5a7 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Thu, 21 Dec 2023 16:09:12 +0000 Subject: [PATCH 025/120] fix: upgrade com.amazonaws:aws-java-sdk-dynamodb from 1.12.596 to 1.12.599 Snyk has created this PR to upgrade com.amazonaws:aws-java-sdk-dynamodb from 1.12.596 to 1.12.599. See this package in Maven Repository: https://mvnrepository.com/artifact/com.amazonaws/aws-java-sdk-dynamodb/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/db3dfb82-467b-4263-94f8-28f933540a6d?utm_source=github&utm_medium=referral&page=upgrade-pr --- adapter-dynamodb/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adapter-dynamodb/pom.xml b/adapter-dynamodb/pom.xml index 0c0c0b8a5..865653b40 100644 --- a/adapter-dynamodb/pom.xml +++ b/adapter-dynamodb/pom.xml @@ -43,7 +43,7 @@ com.amazonaws aws-java-sdk-dynamodb - 1.12.596 + 1.12.599 From 17254c79e81500d02b4e3b24d217c43a9aa8cfdd Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Thu, 21 Dec 2023 16:50:13 +0000 Subject: [PATCH 026/120] fix: upgrade org.mvel:mvel2 from 2.5.0.Final to 2.5.1.Final Snyk has created this PR to upgrade org.mvel:mvel2 from 2.5.0.Final to 2.5.1.Final. See this package in Maven Repository: https://mvnrepository.com/artifact/org.mvel/mvel2/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/e1ef410a-5a4c-4ee4-9dd2-47ee3e1ab590?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 688644d24..411f708ac 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -330,7 +330,7 @@ org.mvel mvel2 - 2.5.0.Final + 2.5.1.Final org.antlr From 080849ba3d556a6824417aebfab3803dc8a7c361 Mon Sep 17 00:00:00 2001 From: Mark Wolters Date: Thu, 21 Dec 2023 15:36:06 -0400 Subject: [PATCH 027/120] fix for values too small to be represented as Double causing NaN from StabilityDetector --- .../scenarios/simframe/stabilization/StatBucket.java | 3 +++ .../scenarios/simframe/stabilization/StatFunctions.java | 3 +++ 2 files changed, 6 insertions(+) diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java index 980138ca8..18e96931c 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java @@ -43,6 +43,9 @@ public final class StatBucket { } else if (Double.isNaN(popped)) { var newMean = mean + ((value - mean) / ringbuf.count()); var dSquaredIncrement = ((value - newMean) * (value - mean)); + // If this value is too small to be interpreted as a double it gets converted to + // zero, which is not what we want. So we use the smallest possible double value + if (dSquaredIncrement == 0) dSquaredIncrement = Double.MIN_VALUE; dSquared += dSquaredIncrement; mean = newMean; } else { diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatFunctions.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatFunctions.java index 77aee3321..e6a1fe90b 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatFunctions.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatFunctions.java @@ -41,6 +41,9 @@ public class StatFunctions { */ public static double sigmoidE4LowPass(double input, double highcut) { double v = 1.0d/(1.0d + Math.pow(Math.E, (10000.0d * (input - (highcut + 0.001d))))); + // If this value is too small to be interpreted as a double it gets converted to + // zero, which is not what we want. So we use the smallest possible double value + if (v == 0) v = Double.MIN_VALUE; return v; } From d2f302d02c59d1a50318094c2e33520ae9a9152c Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Thu, 21 Dec 2023 14:25:37 -0600 Subject: [PATCH 028/120] fixes for DNN angular1 tests --- ...ular1_vTest.java => DNNAngular1VTest.java} | 47 +++++++++---------- 1 file changed, 23 insertions(+), 24 deletions(-) rename virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/{DNN_angular1_vTest.java => DNNAngular1VTest.java} (51%) diff --git a/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_vTest.java b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNNAngular1VTest.java similarity index 51% rename from virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_vTest.java rename to virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNNAngular1VTest.java index 10e985357..7c9550919 100644 --- a/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNN_angular1_vTest.java +++ b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/vectors/dnn/DNNAngular1VTest.java @@ -16,54 +16,54 @@ package io.nosqlbench.virtdata.library.basics.shared.vectors.dnn; -import org.jetbrains.annotations.TestOnly; import org.junit.jupiter.api.Test; -import java.util.ArrayList; import java.util.Arrays; -import java.util.List; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; -class DNN_angular1_vTest { +class DNNAngular1VTest { @Test public void testCosineSimilarity() { - assertThat(cosine_similarity(new float[]{1,2,3,4,5,6,7},new float[]{7,6,5,4,3,2,1})).isEqualTo(0.6); - assertThat(cosine_similarity(new float[]{1,2,3,4,5,6,7},new float[]{1,2,3,4,5,6,7})).isEqualTo(1.0); + assertThat(cosine_similarity(new float[]{1, 2, 3, 4, 5, 6, 7}, new float[]{7, 6, 5, 4, 3, 2, 1})).isEqualTo(0.6); + assertThat(cosine_similarity(new float[]{1, 2, 3, 4, 5, 6, 7}, new float[]{1, 2, 3, 4, 5, 6, 7})).isEqualTo(1.0); } @Test public void testSimpleGeneration() { - DNN_angular1_v vs = new DNN_angular1_v(2,100,3); - assertThat(vs.apply(0)).isEqualTo(new float[]{1,0}); - assertThat(vs.apply(1)).isEqualTo(new float[]{2,2}); - assertThat(vs.apply(2)).isEqualTo(new float[]{3,6}); - assertThat(vs.apply(3)).isEqualTo(new float[]{4,0}); - assertThat(vs.apply(4)).isEqualTo(new float[]{5,5}); - assertThat(vs.apply(5)).isEqualTo(new float[]{6,12}); - assertThat(vs.apply(6)).isEqualTo(new float[]{7,0}); + DNN_angular1_v vs = new DNN_angular1_v(2, 100, 3); + assertThat(vs.apply(0)).isEqualTo(new float[]{1, 0}); + assertThat(vs.apply(1)).isEqualTo(new float[]{2, 2}); + assertThat(vs.apply(2)).isEqualTo(new float[]{3, 6}); + assertThat(vs.apply(3)).isEqualTo(new float[]{4, 0}); + assertThat(vs.apply(4)).isEqualTo(new float[]{5, 5}); + assertThat(vs.apply(5)).isEqualTo(new float[]{6, 12}); + assertThat(vs.apply(6)).isEqualTo(new float[]{7, 0}); } @Test public void testBasicAngularVectors() { - DNN_angular1_v vf = new DNN_angular1_v(10, 100, 7); + int M = 7; + DNN_angular1_v vf = new DNN_angular1_v(10, 100, M); float[][] vectors = new float[100][]; for (int i = 0; i < 100; i++) { vectors[i] = vf.apply(i); } int[] same = new int[100]; - Arrays.fill(same,-1); + Arrays.fill(same, -1); for (int vidx = 0; vidx < same.length; vidx++) { - for (int compare_to = 0; compare_to < vidx; compare_to++) { - if (cosine_similarity(vectors[vidx],vectors[compare_to])==1.0) { - same[vidx]=compare_to; + for (int compare_to = 0; compare_to <= vidx; compare_to++) { + double similarity = cosine_similarity(vectors[vidx], vectors[compare_to]); + if (Math.abs(similarity - 1.0d) < 0.00000001d) { + same[vidx] = compare_to; + break; } } } - for (int sameas = 0; sameas < same.length; sameas++) { - assertThat(same[sameas]==sameas%7); + for (int sameas = M; sameas < same.length; sameas++) { +// System.out.println("idx:" + sameas + ", same[sameas] -> " + same[sameas] + " sameas%7=" + sameas % M); + assertThat(same[sameas] % M).isEqualTo(sameas % M); } } @@ -76,8 +76,7 @@ class DNN_angular1_vTest { as += (a[i] * a[i]); bs += (b[i] * b[i]); } - double similarity = dp / (Math.sqrt(as) * Math.sqrt(bs)); - return similarity; + return dp / (Math.sqrt(as) * Math.sqrt(bs)); } } From af5955e10829ef209013c9d53581d28a9fc04498 Mon Sep 17 00:00:00 2001 From: Mark Wolters Date: Fri, 22 Dec 2023 13:20:26 -0400 Subject: [PATCH 029/120] fix for NaN occurring with small values --- .../scenarios/simframe/stabilization/StatBucket.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java index 18e96931c..ffb98c5a2 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/stabilization/StatBucket.java @@ -51,8 +51,10 @@ public final class StatBucket { } else { var meanIncrement = (value - popped) / ringbuf.count(); var newMean = mean + meanIncrement; - var dSquaredIncrement = ((value - popped) * (value - newMean + popped - mean)); + // If this value is too small to be interpreted as a double it gets converted to + // zero, which is not what we want. So we use the smallest possible double value + if (dSquaredIncrement == 0) dSquaredIncrement = Double.MIN_VALUE; var newDSquared = this.dSquared + dSquaredIncrement; mean = newMean; dSquared = newDSquared; From fe9afb1a6d0f9ec4559541a9a87344963a13b03d Mon Sep 17 00:00:00 2001 From: Mark Wolters Date: Fri, 22 Dec 2023 15:05:13 -0400 Subject: [PATCH 030/120] changed optimo rate param min from 20 to 10, added more informative exception message --- .../scenarios/simframe/optimizers/optimo/CMD_optimo.java | 2 +- .../scenarios/simframe/optimizers/optimo/OptimoParamModel.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java index 4777717c2..1872849aa 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java @@ -83,7 +83,7 @@ public class CMD_optimo extends NBBaseCommand { OptimoSearchSettings optimoSearchParams = new OptimoSearchSettings(params, model); - model.add("rate", 20, optimoSearchParams.startRate(), optimoSearchParams.startRate()*4, + model.add("rate", 10, optimoSearchParams.startRate(), optimoSearchParams.startRate()*4, rate -> flywheel.onEvent(ParamChange.of(new CycleRateSpec(rate, 1.1d, SimRateSpec.Verb.restart))) ); model.add("threads", 10, 50, 2000, diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java index 536696eeb..588005626 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java @@ -29,7 +29,7 @@ public class OptimoParamModel { public OptimoParamModel add(String name, double min, double initial, double max, DoubleConsumer effector) { if (min>initial || initial > max) { - throw new RuntimeException("parameters must be in min Date: Fri, 22 Dec 2023 13:36:58 -0600 Subject: [PATCH 032/120] refactor session safety metrics into auxiliary component --- .../engine/core/lifecycle/session/NBSession.java | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java index 9e98c6e9f..5e3f98ced 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/core/lifecycle/session/NBSession.java @@ -64,7 +64,16 @@ public class NBSession extends NBBaseComponent implements Function, Ex labelContext.getLabels() .and("session", sessionName) ); + new NBSessionSafetyMetrics(this); + + create().gauge( + "session_time", + () -> (double)System.nanoTime(), + MetricCategory.Core, + "session time in nanoseconds" + ); + bufferOrphanedMetrics = true; } From b91648e8a34991223eb49ea4653c0c86b3d92d7c Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Fri, 22 Dec 2023 13:37:01 -0600 Subject: [PATCH 033/120] improve error message for parameter bounds --- .../scenarios/simframe/optimizers/optimo/OptimoParamModel.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java index 536696eeb..588005626 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/OptimoParamModel.java @@ -29,7 +29,7 @@ public class OptimoParamModel { public OptimoParamModel add(String name, double min, double initial, double max, DoubleConsumer effector) { if (min>initial || initial > max) { - throw new RuntimeException("parameters must be in min { diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java index 683b87245..273f272e8 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/instruments/MetricCategory.java @@ -21,6 +21,11 @@ public enum MetricCategory { * Metrics which are essential to understanding the behavior of any activity */ Core, + /** + * Some metrics are provided only to inform the user of relative or absolute progress, + * in terms of cycles remaining or similar + */ + Progress, /** * Metrics which mirror configuration data, either static or dynamic during the lifetime * of an activity, session, or container. These are shared because they may need to be known diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormat.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormat.java index f9de51827..be97ec94e 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormat.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormat.java @@ -17,6 +17,8 @@ package io.nosqlbench.nb.api.engine.metrics.reporters; import com.codahale.metrics.*; +import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; +import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetric; import io.nosqlbench.nb.api.labels.NBLabeledElement; import io.nosqlbench.nb.api.labels.NBLabels; import org.apache.logging.log4j.LogManager; @@ -26,7 +28,9 @@ import java.io.IOException; import java.io.Writer; import java.time.Clock; import java.time.Instant; +import java.util.Arrays; import java.util.Map; +import java.util.stream.Collectors; /** * Format NBMetrics according to the prometheus exposition format. @@ -59,6 +63,16 @@ public class PromExpositionFormat { for (final Object metric : metrics) { NBLabels labels = null; + if (metric instanceof NBMetric nbm) { + MetricCategory[] categories = nbm.getCategories(); + buffer.append("# CATEGORIES: ") + .append(Arrays.stream(categories).map(MetricCategory::name).collect(Collectors.joining(", "))) + .append("\n"); + String description = nbm.getDescription(); + buffer.append("# DESCRIPTION: ").append(description).append("\n"); + + } + if (metric instanceof final NBLabeledElement labeled) labels = labeled.getLabels(); else throw new RuntimeException( "Unknown label set for metric type '" + metric.getClass().getCanonicalName() + '\'' diff --git a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromPushReporterComponent.java b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromPushReporterComponent.java index 587ea2d4c..c88f5ff36 100644 --- a/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromPushReporterComponent.java +++ b/nb-api/src/main/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromPushReporterComponent.java @@ -33,8 +33,10 @@ import java.net.http.HttpRequest; import java.net.http.HttpRequest.BodyPublishers; import java.net.http.HttpResponse; import java.net.http.HttpResponse.BodyHandler; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; +import java.nio.file.StandardOpenOption; import java.time.Clock; import java.time.Duration; import java.time.Instant; @@ -49,18 +51,18 @@ public class PromPushReporterComponent extends PeriodicTaskComponent { private String bearerToken; public PromPushReporterComponent(NBComponent parent, String endpoint, long intervalMs, NBLabels nbLabels) { - super(parent,nbLabels.and("_type","prom-push"),intervalMs,true,"REPORT-PROMPUSH"); + super(parent, nbLabels.and("_type", "prom-push"), intervalMs, true, "REPORT-PROMPUSH"); String jobname = getLabels().valueOfOptional("jobname").orElse("default"); String instance = getLabels().valueOfOptional("instance").orElse("default"); - if (jobname.equals("default")||instance.equals("default")) { + if (jobname.equals("default") || instance.equals("default")) { logger.warn("It is highly recommended that you set a value for labels jobname and instance other than 'default'."); } if (endpoint.matches("victoria:[a-zA-Z0-9._-]+:[0-9]+")) { String[] parts = endpoint.split(":", 2); - endpoint = "https://"+parts[1]+"/api/v1/import/prometheus/metrics/job/JOBNAME/instance/INSTANCE"; + endpoint = "https://" + parts[1] + "/api/v1/import/prometheus/metrics/job/JOBNAME/instance/INSTANCE"; } - endpoint=endpoint.replace("JOBNAME",jobname).replace("INSTANCE",instance); + endpoint = endpoint.replace("JOBNAME", jobname).replace("INSTANCE", instance); if (!endpoint.contains(jobname)) { throw new BasicError("Mismatch between jobname in prompush URI and specified jobname label. You should use the short form for --report-prompush-to victoria:addr:port and set the jobname with --add-labels"); } @@ -109,9 +111,24 @@ public class PromPushReporterComponent extends PeriodicTaskComponent { remainingRetries--; final HttpClient client = getCachedClient(); final HttpRequest.Builder rb = HttpRequest.newBuilder().uri(uri); - if (bearerToken!=null) { + if (bearerToken != null) { rb.setHeader("Authorization", "Bearer " + bearerToken); } + getComponentProp("prompush_cache") + .map(cache -> Path.of(getComponentProp("logsdir").orElse(".")) + .resolve("cache")).ifPresent( + prompush_cache_path -> { + try { + Files.writeString( + prompush_cache_path, + exposition, + StandardOpenOption.TRUNCATE_EXISTING, + StandardOpenOption.CREATE, + StandardOpenOption.WRITE); + } catch (IOException e) { + throw new RuntimeException(e); + } + }); final HttpRequest request = rb.POST(BodyPublishers.ofString(exposition)).build(); final BodyHandler handler = HttpResponse.BodyHandlers.ofString(); HttpResponse response = null; From ecdf38ebe89e4ac1eaddbb1aadecd7416a4d6bbe Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Fri, 22 Dec 2023 13:41:08 -0600 Subject: [PATCH 035/120] unit test fixes for doc format --- .../metrics/reporters/PromExpositionFormatTest.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java b/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java index 674d2aab9..c20fbecef 100644 --- a/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java +++ b/nb-api/src/test/java/io/nosqlbench/nb/api/engine/metrics/reporters/PromExpositionFormatTest.java @@ -55,6 +55,8 @@ public class PromExpositionFormatTest { String buffer = PromExpositionFormat.format(nowclock, counter); assertThat(buffer).matches(Pattern.compile(""" + # CATEGORIES: Verification + # DESCRIPTION: test counter format # TYPE counter_test_2342_total counter counter_test_2342_total\\{origin="mars"} \\d+ \\d+ """)); @@ -77,6 +79,8 @@ public class PromExpositionFormatTest { String formatted = PromExpositionFormat.format(nowclock, nbHistogram); assertThat(formatted).matches(Pattern.compile(""" + # CATEGORIES: Verification + # DESCRIPTION: test histogram format # TYPE mynameismud_total counter mynameismud_total\\{label3="value3"} 0 \\d+ # TYPE mynameismud histogram @@ -116,6 +120,8 @@ public class PromExpositionFormatTest { String formatted = PromExpositionFormat.format(nowclock, nbMetricTimer); assertThat(formatted).matches(Pattern.compile(""" + # CATEGORIES: Verification + # DESCRIPTION: test timer format # TYPE monsieurmarius_total counter monsieurmarius_total\\{label4="value4"} 1000 \\d+ # TYPE monsieurmarius histogram @@ -157,6 +163,8 @@ public class PromExpositionFormatTest { String formatted = PromExpositionFormat.format(nowclock, nbMetricMeter); assertThat(formatted).matches(Pattern.compile(""" + # CATEGORIES: Verification + # DESCRIPTION: test meter format # TYPE eponine_total counter eponine_total\\{label5="value5"} 0 \\d+ # TYPE eponine_1mRate gauge @@ -182,6 +190,8 @@ public class PromExpositionFormatTest { String formatted = PromExpositionFormat.format(nowclock, nbMetricGauge); assertThat(formatted).matches(Pattern.compile(""" + # CATEGORIES: Verification + # DESCRIPTION: test gauge format # TYPE cosette gauge cosette\\{label6="value6"} 1500.0 """)); @@ -196,6 +206,8 @@ public class PromExpositionFormatTest { String formatted2 = PromExpositionFormat.format(nowclock, nbMetricGauge2); assertThat(formatted2).matches(Pattern.compile(""" + # CATEGORIES: Verification + # DESCRIPTION: test gauge format 2 # TYPE cosette2 gauge cosette2\\{label7="value7"} 2000.0 """)); From b9008c75f58b76b4572de6774ac067a72f004a47 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Thu, 28 Dec 2023 17:15:09 +0000 Subject: [PATCH 036/120] fix: upgrade io.dropwizard.metrics:metrics-core from 4.2.22 to 4.2.23 Snyk has created this PR to upgrade io.dropwizard.metrics:metrics-core from 4.2.22 to 4.2.23. See this package in Maven Repository: https://mvnrepository.com/artifact/io.dropwizard.metrics/metrics-core/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/024e32ec-7f80-485c-b7bf-f69d45f933ce?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 688644d24..4b68ba0e1 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -127,7 +127,7 @@ io.dropwizard.metrics metrics-core - 4.2.22 + 4.2.23 org.apache.commons From 5b5a2cc26a6a4987957b37f568454a874a3e4a1c Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Thu, 28 Dec 2023 19:55:06 +0000 Subject: [PATCH 037/120] fix: upgrade io.dropwizard.metrics:metrics-graphite from 4.2.22 to 4.2.23 Snyk has created this PR to upgrade io.dropwizard.metrics:metrics-graphite from 4.2.22 to 4.2.23. See this package in Maven Repository: https://mvnrepository.com/artifact/io.dropwizard.metrics/metrics-graphite/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/6a966a50-08ee-405a-ae9a-1cfab95ff2c5?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 688644d24..b4b5237d5 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -122,7 +122,7 @@ io.dropwizard.metrics metrics-graphite - 4.2.22 + 4.2.23 io.dropwizard.metrics From 945638e720ec9091ff075aae6f4d5b2494be1fa4 Mon Sep 17 00:00:00 2001 From: snyk-bot Date: Mon, 1 Jan 2024 18:54:49 +0000 Subject: [PATCH 038/120] fix: upgrade net.java.dev.jna:jna-platform from 5.13.0 to 5.14.0 Snyk has created this PR to upgrade net.java.dev.jna:jna-platform from 5.13.0 to 5.14.0. See this package in Maven Repository: https://mvnrepository.com/artifact/net.java.dev.jna/jna-platform/ See this project in Snyk: https://app.snyk.io/org/nosqlbench/project/024e32ec-7f80-485c-b7bf-f69d45f933ce?utm_source=github&utm_medium=referral&page=upgrade-pr --- mvn-defaults/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index 688644d24..aeefe09ae 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -101,7 +101,7 @@ net.java.dev.jna jna-platform - 5.13.0 + 5.14.0 org.junit.jupiter From 01bd518612f323b6ce52fc29126640818e01b7fa Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 2 Jan 2024 11:34:05 -0600 Subject: [PATCH 039/120] move simrate to its own package --- .../io/nosqlbench/adapter/diag/DiagOpDispenser.java | 2 +- .../java/io/nosqlbench/adapter/diag/DiagSpace.java | 2 +- .../adapter/diag/optasks/DiagTask_diagrate.java | 6 +++--- .../engine/api/activityapi/core/Activity.java | 2 +- .../{ratelimits => }/simrate/CycleRateSpec.java | 2 +- .../{ratelimits => simrate}/RateLimiter.java | 4 ++-- .../{ratelimits => simrate}/RateLimiters.java | 4 +--- .../activityapi/{ratelimits => }/simrate/SimRate.java | 3 +-- .../{ratelimits => }/simrate/SimRateSpec.java | 2 +- .../{ratelimits => }/simrate/SimThreads.java | 2 +- .../{ratelimits => }/simrate/StrideRateSpec.java | 2 +- .../engine/api/activityimpl/SimpleActivity.java | 10 +++++----- .../engine/api/activityimpl/motor/CoreMotor.java | 6 +----- .../api/activityimpl/uniform/StandardActivity.java | 4 ++-- .../api/activityapi/ratelimits/SimRateSpecTest.java | 2 +- .../nosqlbench/engine/sandbox/SimRateSanityTest.java | 4 ++-- .../java/io/nosqlbench/engine/sandbox/SimRateTest.java | 4 ++-- .../nbr/examples/injava/NB_cocycledelay_bursty.java | 2 +- .../nosqlbench/scenarios/simframe/SimFrameUtils.java | 4 ++-- .../simframe/optimizers/optimo/CMD_optimo.java | 4 ++-- .../optimizers/planners/findmax/FindmaxPlanner.java | 6 ++---- .../optimizers/planners/ratchet/RatchetPlanner.java | 6 ++---- .../optimizers/planners/rcurve/RCurvePlanner.java | 4 ++-- 23 files changed, 38 insertions(+), 49 deletions(-) rename engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/{ratelimits => }/simrate/CycleRateSpec.java (94%) rename engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/{ratelimits => simrate}/RateLimiter.java (95%) rename engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/{ratelimits => simrate}/RateLimiters.java (86%) rename engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/{ratelimits => }/simrate/SimRate.java (99%) rename engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/{ratelimits => }/simrate/SimRateSpec.java (99%) rename engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/{ratelimits => }/simrate/SimThreads.java (97%) rename engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/{ratelimits => }/simrate/StrideRateSpec.java (94%) diff --git a/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagOpDispenser.java b/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagOpDispenser.java index 203604981..6c3c72bc4 100644 --- a/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagOpDispenser.java +++ b/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagOpDispenser.java @@ -23,7 +23,7 @@ import io.nosqlbench.nb.api.config.standard.NBConfigModel; import io.nosqlbench.nb.api.config.standard.NBConfiguration; import io.nosqlbench.nb.api.config.standard.NBReconfigurable; import io.nosqlbench.nb.api.components.core.NBParentComponentInjection; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiter; import io.nosqlbench.nb.annotations.ServiceSelector; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; diff --git a/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagSpace.java b/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagSpace.java index a41b04898..7d0a8928a 100644 --- a/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagSpace.java +++ b/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/DiagSpace.java @@ -17,7 +17,7 @@ package io.nosqlbench.adapter.diag; import io.nosqlbench.engine.api.activityapi.core.ActivityDefObserver; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiter; import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef; import io.nosqlbench.nb.api.config.standard.ConfigModel; import io.nosqlbench.nb.api.config.standard.NBConfigModel; diff --git a/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/optasks/DiagTask_diagrate.java b/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/optasks/DiagTask_diagrate.java index 37c50367d..eef207739 100644 --- a/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/optasks/DiagTask_diagrate.java +++ b/adapter-diag/src/main/java/io/nosqlbench/adapter/diag/optasks/DiagTask_diagrate.java @@ -16,9 +16,9 @@ package io.nosqlbench.adapter.diag.optasks; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiters; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiter; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiters; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import io.nosqlbench.nb.annotations.Service; import io.nosqlbench.nb.api.config.standard.*; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/Activity.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/Activity.java index 9dcd74d71..5ab967f9f 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/Activity.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/core/Activity.java @@ -25,7 +25,7 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.filters.IntPredicateDispens import io.nosqlbench.engine.api.activityapi.errorhandling.ErrorMetrics; import io.nosqlbench.engine.api.activityapi.input.InputDispenser; import io.nosqlbench.engine.api.activityapi.output.OutputDispenser; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiter; import io.nosqlbench.engine.api.activityimpl.SimpleActivity; import io.nosqlbench.engine.api.activityimpl.motor.RunStateTally; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/CycleRateSpec.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/CycleRateSpec.java similarity index 94% rename from engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/CycleRateSpec.java rename to engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/CycleRateSpec.java index b4c0b39b5..cf386ff31 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/CycleRateSpec.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/CycleRateSpec.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.engine.api.activityapi.ratelimits.simrate; +package io.nosqlbench.engine.api.activityapi.simrate; import io.nosqlbench.nb.api.engine.activityimpl.ParameterMap; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiter.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/RateLimiter.java similarity index 95% rename from engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiter.java rename to engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/RateLimiter.java index 01f95c7eb..8112c90ad 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiter.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/RateLimiter.java @@ -14,9 +14,9 @@ * limitations under the License. */ -package io.nosqlbench.engine.api.activityapi.ratelimits; +package io.nosqlbench.engine.api.activityapi.simrate; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import java.time.Duration; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiters.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/RateLimiters.java similarity index 86% rename from engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiters.java rename to engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/RateLimiters.java index 1a52e0990..676a873e6 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiters.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/RateLimiters.java @@ -14,11 +14,9 @@ * limitations under the License. */ -package io.nosqlbench.engine.api.activityapi.ratelimits; +package io.nosqlbench.engine.api.activityapi.simrate; import io.nosqlbench.nb.api.components.core.NBComponent; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRate; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRate.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimRate.java similarity index 99% rename from engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRate.java rename to engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimRate.java index d93430e13..9488b60d6 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRate.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimRate.java @@ -14,13 +14,12 @@ * limitations under the License. */ -package io.nosqlbench.engine.api.activityapi.ratelimits.simrate; +package io.nosqlbench.engine.api.activityapi.simrate; import io.nosqlbench.nb.api.engine.metrics.instruments.MetricCategory; import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.core.NBComponent; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRateSpec.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimRateSpec.java similarity index 99% rename from engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRateSpec.java rename to engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimRateSpec.java index 710f0fa79..6dfdca1c6 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimRateSpec.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimRateSpec.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.engine.api.activityapi.ratelimits.simrate; +package io.nosqlbench.engine.api.activityapi.simrate; import io.nosqlbench.nb.api.engine.activityimpl.ParameterMap; import io.nosqlbench.nb.api.engine.util.Unit; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimThreads.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimThreads.java similarity index 97% rename from engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimThreads.java rename to engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimThreads.java index ae42e790e..caca422a6 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/SimThreads.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/SimThreads.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.engine.api.activityapi.ratelimits.simrate; +package io.nosqlbench.engine.api.activityapi.simrate; import java.util.concurrent.Semaphore; import java.util.function.Function; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/StrideRateSpec.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/StrideRateSpec.java similarity index 94% rename from engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/StrideRateSpec.java rename to engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/StrideRateSpec.java index 64791cb31..23e679176 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/simrate/StrideRateSpec.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityapi/simrate/StrideRateSpec.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package io.nosqlbench.engine.api.activityapi.ratelimits.simrate; +package io.nosqlbench.engine.api.activityapi.simrate; import io.nosqlbench.nb.api.engine.activityimpl.ParameterMap; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/SimpleActivity.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/SimpleActivity.java index 706cb3560..ca4670583 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/SimpleActivity.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/SimpleActivity.java @@ -29,9 +29,9 @@ import io.nosqlbench.engine.api.activityapi.errorhandling.ErrorMetrics; import io.nosqlbench.engine.api.activityapi.errorhandling.modular.NBErrorHandler; import io.nosqlbench.engine.api.activityapi.planning.OpSequence; import io.nosqlbench.engine.api.activityapi.planning.SequencerType; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiters; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiters; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import io.nosqlbench.adapters.api.activityimpl.OpDispenser; import io.nosqlbench.adapters.api.activityimpl.OpMapper; import io.nosqlbench.nb.api.labels.NBLabels; @@ -42,12 +42,12 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.filters.IntPredicateDispens import io.nosqlbench.engine.api.activityapi.input.InputDispenser; import io.nosqlbench.engine.api.activityapi.output.OutputDispenser; import io.nosqlbench.engine.api.activityapi.planning.SequencePlanner; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiter; import io.nosqlbench.adapters.api.activityconfig.OpsLoader; import io.nosqlbench.adapters.api.activityconfig.yaml.OpTemplate; import io.nosqlbench.adapters.api.activityconfig.yaml.OpTemplateFormat; import io.nosqlbench.adapters.api.activityconfig.yaml.OpsDocList; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.StrideRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.StrideRateSpec; import io.nosqlbench.engine.api.activityimpl.motor.RunStateTally; import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter; import io.nosqlbench.adapters.api.activityimpl.uniform.DryRunOpDispenserWrapper; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java index 82d76c614..ddaf76329 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java @@ -15,20 +15,16 @@ */ package io.nosqlbench.engine.api.activityimpl.motor; -import com.codahale.metrics.Counter; import com.codahale.metrics.Timer; import io.nosqlbench.engine.api.activityapi.core.*; -import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.TrackedOp; -import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.op_output.StrideOutputConsumer; import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResultSegmentBuffer; import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResultsSegment; import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleSegment; import io.nosqlbench.engine.api.activityimpl.MotorState; import io.nosqlbench.engine.api.activityapi.core.ops.fluent.OpTracker; -import io.nosqlbench.engine.api.activityapi.core.ops.fluent.OpTrackerImpl; import io.nosqlbench.engine.api.activityapi.input.Input; import io.nosqlbench.engine.api.activityapi.output.Output; -import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter; +import io.nosqlbench.engine.api.activityapi.simrate.RateLimiter; import io.nosqlbench.nb.api.engine.activityimpl.ActivityDef; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.LogManager; diff --git a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java index 31cadabe1..35d1642b9 100644 --- a/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java +++ b/engine-core/src/main/java/io/nosqlbench/engine/api/activityimpl/uniform/StandardActivity.java @@ -39,8 +39,8 @@ import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.nb.api.components.events.SetThreads; import io.nosqlbench.engine.api.activityapi.core.ActivityDefObserver; import io.nosqlbench.engine.api.activityapi.planning.OpSequence; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.StrideRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.StrideRateSpec; import io.nosqlbench.engine.api.activityimpl.SimpleActivity; import io.nosqlbench.nb.annotations.ServiceSelector; import org.apache.logging.log4j.LogManager; diff --git a/engine-core/src/test/java/io/nosqlbench/engine/api/activityapi/ratelimits/SimRateSpecTest.java b/engine-core/src/test/java/io/nosqlbench/engine/api/activityapi/ratelimits/SimRateSpecTest.java index d6438d6a6..1ca9a6c1c 100644 --- a/engine-core/src/test/java/io/nosqlbench/engine/api/activityapi/ratelimits/SimRateSpecTest.java +++ b/engine-core/src/test/java/io/nosqlbench/engine/api/activityapi/ratelimits/SimRateSpecTest.java @@ -16,7 +16,7 @@ package io.nosqlbench.engine.api.activityapi.ratelimits; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import org.junit.jupiter.api.Test; import static org.assertj.core.api.Assertions.assertThat; diff --git a/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateSanityTest.java b/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateSanityTest.java index 761624069..a2498a4a3 100644 --- a/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateSanityTest.java +++ b/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateSanityTest.java @@ -18,8 +18,8 @@ package io.nosqlbench.engine.sandbox; import io.nosqlbench.nb.api.config.standard.TestComponent; import io.nosqlbench.nb.api.components.core.NBComponent; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRate; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRate; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import org.junit.jupiter.api.Disabled; import org.openjdk.jmh.annotations.*; import org.openjdk.jmh.runner.Runner; diff --git a/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateTest.java b/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateTest.java index dddef78be..17a9551cd 100644 --- a/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateTest.java +++ b/engine-core/src/test/java/io/nosqlbench/engine/sandbox/SimRateTest.java @@ -18,8 +18,8 @@ package io.nosqlbench.engine.sandbox; import io.nosqlbench.nb.api.config.standard.TestComponent; import io.nosqlbench.nb.api.components.core.NBComponent; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRate; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRate; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.openjdk.jmh.annotations.*; diff --git a/nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cocycledelay_bursty.java b/nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cocycledelay_bursty.java index eda7766f6..1d98d41e2 100644 --- a/nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cocycledelay_bursty.java +++ b/nbr-examples/src/test/java/io/nosqlbench/nbr/examples/injava/NB_cocycledelay_bursty.java @@ -24,7 +24,7 @@ import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer; import io.nosqlbench.nb.api.components.core.NBComponent; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.engine.api.activityapi.core.Activity; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/SimFrameUtils.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/SimFrameUtils.java index 4da4f34e5..388e78c4d 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/SimFrameUtils.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/SimFrameUtils.java @@ -17,8 +17,8 @@ package io.nosqlbench.scenarios.simframe; import io.nosqlbench.engine.api.activityapi.core.Activity; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java index 1872849aa..56564e13b 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/optimo/CMD_optimo.java @@ -24,8 +24,8 @@ import io.nosqlbench.nb.api.engine.metrics.instruments.NBMetricTimer; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.nb.api.components.events.SetThreads; import io.nosqlbench.engine.api.activityapi.core.Activity; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.ContainerActivitiesController; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; import io.nosqlbench.scenarios.simframe.SimFrameUtils; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java index ec27fc4c0..642f5ec43 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/findmax/FindmaxPlanner.java @@ -17,16 +17,14 @@ package io.nosqlbench.scenarios.simframe.optimizers.planners.findmax; import io.nosqlbench.engine.api.activityapi.core.Activity; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.scenarios.simframe.capture.JournalView; import io.nosqlbench.scenarios.simframe.planning.SimFrame; import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import java.util.Comparator; diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java index 8e186c7ea..ca0f3d2e3 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/ratchet/RatchetPlanner.java @@ -17,16 +17,14 @@ package io.nosqlbench.scenarios.simframe.optimizers.planners.ratchet; import io.nosqlbench.engine.api.activityapi.core.Activity; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.events.ParamChange; import io.nosqlbench.scenarios.simframe.capture.JournalView; import io.nosqlbench.scenarios.simframe.planning.SimFrame; import io.nosqlbench.scenarios.simframe.planning.SimFramePlanner; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; public class RatchetPlanner extends SimFramePlanner { public RatchetPlanner(NBBaseComponent parent, NBCommandParams params) { diff --git a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java index 9c8de4000..10c4fa9fb 100644 --- a/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java +++ b/nbr/src/main/java/io/nosqlbench/scenarios/simframe/optimizers/planners/rcurve/RCurvePlanner.java @@ -17,8 +17,8 @@ package io.nosqlbench.scenarios.simframe.optimizers.planners.rcurve; import io.nosqlbench.engine.api.activityapi.core.Activity; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.CycleRateSpec; -import io.nosqlbench.engine.api.activityapi.ratelimits.simrate.SimRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.CycleRateSpec; +import io.nosqlbench.engine.api.activityapi.simrate.SimRateSpec; import io.nosqlbench.engine.core.lifecycle.scenario.container.NBCommandParams; import io.nosqlbench.nb.api.components.core.NBBaseComponent; import io.nosqlbench.nb.api.components.events.ParamChange; From a3283ab06f0398b6b45732d5740534529531b6ec Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 2 Jan 2024 12:27:43 -0600 Subject: [PATCH 040/120] remove read-only config parameter --- mvn-defaults/pom.xml | 1 - 1 file changed, 1 deletion(-) diff --git a/mvn-defaults/pom.xml b/mvn-defaults/pom.xml index acd3866e3..cb7c6c34e 100644 --- a/mvn-defaults/pom.xml +++ b/mvn-defaults/pom.xml @@ -641,7 +641,6 @@ 21 ${javadoc.name} ${javadoc.name} - false false false false From 3fd98f0044ce8794c845256b79dcee13398946a1 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 2 Jan 2024 12:36:03 -0600 Subject: [PATCH 041/120] testing workflow fixes --- .github/workflows/build.yml | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 1177173e1..196d6e95e 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -14,24 +14,20 @@ jobs: build: runs-on: ubuntu-20.04 steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 name: checkout nosqlbench - with: - node-version: '16' - - uses: actions/setup-java@v3 + - uses: actions/setup-java@v4 name: setup java with: - node-version: '16' - java-version: '21' - java-package: jdk architecture: x64 distribution: 'oracle' + java-package: jdk + java-version: '21' - name: Cache Maven packages - uses: actions/cache@v1 + uses: actions/cache@v3 with: - node-version: '16' path: ~/.m2 key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} restore-keys: ${{ runner.os }}-m2 @@ -71,9 +67,8 @@ jobs: - name: upload docs artifact if: success() - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: - node-version: '16' name: exported-docs path: exported_docs.zip @@ -90,9 +85,8 @@ jobs: run: git config --global user.name "${{ secrets.NBDROID_NAME }}" - name: download exported_docs - uses: actions/download-artifact@v3 + uses: actions/download-artifact@v4 with: - node-version: '16' name: exported-docs - run: ls -la From 49d2c41c9fff763996a62793c0be4ae261df6583 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 2 Jan 2024 12:47:57 -0600 Subject: [PATCH 042/120] add missing logfile for main and test scope --- .../src/{test/resources => main}/log4j2.xml | 0 nb-api/src/test/resources/log4j2-test.xml | 56 +++++++++++++++++++ 2 files changed, 56 insertions(+) rename nb-api/src/{test/resources => main}/log4j2.xml (100%) create mode 100644 nb-api/src/test/resources/log4j2-test.xml diff --git a/nb-api/src/test/resources/log4j2.xml b/nb-api/src/main/log4j2.xml similarity index 100% rename from nb-api/src/test/resources/log4j2.xml rename to nb-api/src/main/log4j2.xml diff --git a/nb-api/src/test/resources/log4j2-test.xml b/nb-api/src/test/resources/log4j2-test.xml new file mode 100644 index 000000000..48588be00 --- /dev/null +++ b/nb-api/src/test/resources/log4j2-test.xml @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + + + + + + + %d %p %C{1.} [%t] %m%n + + + + + + + + + + + + + + + + + From dfcbb1826c3ccb9ffa6c5aaaa07c2437dc430130 Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Tue, 2 Jan 2024 12:50:14 -0600 Subject: [PATCH 043/120] minor copyright update --- nb-api/src/main/log4j2.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nb-api/src/main/log4j2.xml b/nb-api/src/main/log4j2.xml index 003d82533..1f356bc2d 100644 --- a/nb-api/src/main/log4j2.xml +++ b/nb-api/src/main/log4j2.xml @@ -1,6 +1,6 @@