Introduce new parameters for memory and class reg.

Introduce new parameters for explicity class and memory
registration. Both parameters shall be provided before
`-C` parameter.

Syntax is as follow:
* -M[p] for memory registration. The `p` value inidcates
  the usage of persisten memory
* -R[d] for class registration. The `d` value indicates
  the usage of `BTR_FEAT_DIRECT_KEY` flag - root is
  dynamically sized up to tree order.

Parameters `-t` and `-d` are no longer valid.

Signed-off-by: Tomasz Gromadzki <[email protected]>

Author: grom72

src/common/tests/btree.c

@@ -888,8 +888,8 @@ ik_btr_drain(void **state)
 
 static struct option btr_ops[] = {
     {"start-test", required_argument, NULL, 'S'},
-    {"dyn_tree", no_argument, NULL, 't'},
-    {"pmem", no_argument, NULL, 'm'},
+    {"reg_class", optional_argument, NULL, 'R'},
+    {"reg_memory", optional_argument, NULL, 'M'},
     {"create", required_argument, NULL, 'C'},
     {"destroy", no_argument, NULL, 'D'},
     {"drain", no_argument, NULL, 'e'},
@@ -906,13 +906,16 @@ static struct option btr_ops[] = {
     {NULL, 0, NULL, 0},
 };
 
-#define BTR_SHORTOPTS "+S:tmC:Deocqu:f:d:r:qi:b:p:"
+#define BTR_SHORTOPTS "+S:R::M::C:Deocqu:f:d:r:qi:b:p:"
 
 static void
-ik_btr_init_mem(bool pmem, int dynamic_flag)
+ik_btr_memory_register(char *pmem_flag)
 {
 	int rc = 0;
-	if (pmem) {
+	if (pmem_flag && *pmem_flag != 'p') {
+		fail_msg("Invalid value of -M parameter: %c\n", *pmem_flag);
+	}
+	if (pmem_flag) {
 		D_PRINT("Using pmem\n");
 		rc = utest_pmem_create(POOL_NAME, POOL_SIZE, sizeof(*ik_root), NULL, &ik_utx);
 		if (rc) {
@@ -925,16 +928,29 @@ ik_btr_init_mem(bool pmem, int dynamic_flag)
 			fail_msg("Cannot setup vmem: %d\n", rc);
 		}
 	}
-	rc = dbtree_class_register(
-	    IK_TREE_CLASS, dynamic_flag | BTR_FEAT_EMBED_FIRST | BTR_FEAT_UINT_KEY, &ik_ops);
-	if (rc) {
-		fail_msg("Cannot register memory class: %d\n", rc);
-	}
 
 	ik_root = utest_utx2root(ik_utx);
 	ik_uma  = utest_utx2uma(ik_utx);
 }
 
+static void
+ik_btr_class_register(char *dynamic_flag)
+{
+	if (dynamic_flag && *dynamic_flag != 'd') {
+		fail_msg("Invalid value of -R parameter: %c\n", *dynamic_flag);
+	}
+	if (dynamic_flag) {
+		D_PRINT("Using dynamic tree order\n");
+	}
+	int rc = dbtree_class_register(IK_TREE_CLASS,
+				       (dynamic_flag ? BTR_FEAT_DYNAMIC_ROOT : 0) |
+					   BTR_FEAT_EMBED_FIRST | BTR_FEAT_UINT_KEY,
+				       &ik_ops);
+	if (rc) {
+		fail_msg("Cannot register memory class: %d\n", rc);
+	}
+}
+
 /**
  * Execute test based on the given sequence of steps.
  * -S/--start-test parameter is ignored
@@ -947,28 +963,30 @@ static void
 ts_group(void **state) {
 	struct btr_test_state *test_state    = (struct btr_test_state *)*state;
 	int	opt = 0;
-	void	**st = NULL;
-	int                    dynamic_flag  = 0;
+	void                 **st            = NULL;
 
 	while ((opt = getopt_long(test_state->argc, test_state->argv, BTR_SHORTOPTS, btr_ops,
 				  NULL)) != -1) {
 		tst_fn_val.optval = optarg;
 		tst_fn_val.input = true;
 
+		// trim trailing space
+		while (tst_fn_val.optval && *tst_fn_val.optval != '\0' &&
+		       isspace((unsigned char)*tst_fn_val.optval)) {
+			tst_fn_val.optval++;
+		}
+
 		switch (opt) {
 		case 'S':
 			/* not part of the test sequence */
 			break;
-		case 't':
-			D_PRINT("Using dynamic tree order\n");
-			dynamic_flag = BTR_FEAT_DYNAMIC_ROOT;
+		case 'R':
+			ik_btr_class_register(tst_fn_val.optval);
 			break;
-		case 'm':
-			ik_btr_init_mem(true, dynamic_flag);
+		case 'M':
+			ik_btr_memory_register(tst_fn_val.optval);
 			break;
 		case 'C':
-			if (ik_utx == NULL)
-				ik_btr_init_mem(false, dynamic_flag);
 			ik_btr_open_create(st);
 			break;
 		case 'D':
@@ -1055,6 +1073,10 @@ main(int argc, char **argv)
 		if (opt == 'S') {
 			test_name = optarg;
 		}
+		if (opt == '?') {
+			/* unknown parameter */
+			break;
+		}
 	}
 	if (argc != optind) {
 		print_message("Unknown parameter: %s\n", argv[optind]);

src/common/tests/btree.sh

@@ -40,6 +40,7 @@ EOF
 
 PERF=""
 UINT=""
+DYN=""
 test_conf_pre=""
 while [ $# -gt 0 ]; do
     case "$1" in
@@ -54,7 +55,7 @@ while [ $# -gt 0 ]; do
         test_conf_pre="${test_conf_pre} keys=${BAT_NUM}"
         ;;
     dyn)
-        DYN="-t"
+        DYN="d"
         shift
         test_conf_pre="${test_conf_pre} dyn"
         ;;
@@ -110,7 +111,7 @@ run_test()
         DAOS_DEBUG="$DDEBUG"                        \
         eval "${VCMD}" "$BTR"                       \
         --start-test "'btree functional ${test_conf_pre} ${test_conf} iterate=${IDIR}'" \
-        "${DYN}" "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
+        -R "${DYN}" -M "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
         -c                                          \
         -o                                          \
         -u "$RECORDS"                               \
@@ -130,7 +131,7 @@ run_test()
         echo "B+tree batch operations test..."
         eval "${VCMD}" "$BTR" \
         --start-test "'btree batch operations ${test_conf_pre} ${test_conf}'" \
-        "${DYN}" "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
+        -R "${DYN}" -M "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
         -c                                          \
         -o                                          \
         -b "$BAT_NUM"                               \
@@ -139,22 +140,22 @@ run_test()
         echo "B+tree drain test..."
         eval "${VCMD}" "$BTR" \
         --start-test "'btree drain ${test_conf_pre} ${test_conf}'" \
-        "${DYN}" "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
+        -R "${DYN}" -M "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
         -e -D
 
     else
         echo "B+tree performance test..."
         eval "${VCMD}" "$BTR" \
         --start-test "'btree performance ${test_conf_pre} ${test_conf}'" \
-        "${DYN}" "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
+        -R "${DYN}" -M "${PMEM}" -C "${UINT}${IPL}o:$ORDER" \
         -p "$BAT_NUM"                               \
         -D
     fi
 }
 
 for IPL in "i," ""; do
     for IDIR in "f" "b"; do
-        for PMEM in "-m" ""; do
+        for PMEM in "p" ""; do
             run_test
         done
     done