Motr  M0
parser.c
Go to the documentation of this file.
1 /* -*- C -*- */
2 /*
3  * Copyright (c) 2017-2020 Seagate Technology LLC and/or its Affiliates
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  * For any questions about this software or licensing,
18  * please email opensource@seagate.com or cortx-questions@seagate.com.
19  *
20  */
21 
22 
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdbool.h>
26 #include <errno.h>
27 #include <stdarg.h>
28 
29 #include "motr/m0crate/parser.h"
30 #include "motr/m0crate/crate_client.h"
31 
32 enum cr_kvs_key_len_max {
33  MAX_KEY_LEN = 128
34 };
35 
36 extern struct workload_type_ops ops;
37 extern struct workload_type_ops index_ops;
38 extern struct crate_conf *conf;
39 
40 enum config_key_val {
41  INVALID_OPT = -1,
42  LOCAL_ADDR,
43  HA_ADDR,
44  PROF,
45  LAYOUT_ID,
46  IS_OOSTORE,
47  IS_READ_VERIFY,
48  MAX_QUEUE_LEN,
49  MAX_RPC_MSG,
50  PROCESS_FID,
51  IDX_SERVICE_ID,
52  CASS_EP,
53  CASS_KEYSPACE,
54  CASS_COL_FAMILY,
55  ADDB_INIT,
56  ADDB_SIZE,
57  LOG_LEVEL,
58  /*
59  * All parameters below are workload-specific,
60  * anything else should be added above this point.
61  * The check for index at copy_value() relies on this.
62  */
63  WORKLOAD_TYPE,
64  POOL_FID,
65  SEED,
66  NR_THREADS,
67  NUM_OPS,
68  NR_OBJS,
69  NUM_IDX,
70  NUM_KVP,
71  PUT,
72  GET,
73  NEXT,
74  DEL,
75  NXRECORDS,
76  OP_COUNT,
77  EXEC_TIME,
78  WARMUP_PUT_CNT,
79  WARMUP_DEL_RATIO,
80  KEY_PREFIX,
81  KEY_ORDER,
82  KEY_SIZE,
83  VALUE_SIZE,
84  MAX_KEY_SIZE,
85  MAX_VALUE_SIZE,
86  INDEX_FID,
87  THREAD_OPS,
88  BLOCK_SIZE,
89  BLOCKS_PER_OP,
90  IOSIZE,
91  SOURCE_FILE,
92  RAND_IO,
93  OPCODE,
94  START_OBJ_ID,
95  MODE,
96  MAX_NR_OPS,
97  NR_ROUNDS,
98 };
99 
100 struct key_lookup_table {
101  char *key;
102  enum config_key_val index;
103 };
104 
105 struct key_lookup_table lookuptable[] = {
106  {"MOTR_LOCAL_ADDR", LOCAL_ADDR},
107  {"MOTR_HA_ADDR", HA_ADDR},
108  {"PROF", PROF},
109  {"LAYOUT_ID", LAYOUT_ID},
110  {"IS_OOSTORE", IS_OOSTORE},
111  {"IS_READ_VERIFY", IS_READ_VERIFY},
112  {"TM_RECV_QUEUE_MIN_LEN", MAX_QUEUE_LEN},
113  {"M0_MAX_RPC_MSG_SIZE", MAX_RPC_MSG},
114  {"PROCESS_FID", PROCESS_FID},
115  {"IDX_SERVICE_ID", IDX_SERVICE_ID},
116  {"CASS_CLUSTER_EP", CASS_EP},
117  {"CASS_KEYSPACE", CASS_KEYSPACE},
118  {"CASS_MAX_COL_FAMILY_NUM", CASS_COL_FAMILY},
119  {"ADDB_INIT", ADDB_INIT},
120  {"ADDB_SIZE", ADDB_SIZE},
121  {"WORKLOAD_TYPE", WORKLOAD_TYPE},
122  {"WORKLOAD_SEED", SEED},
123  {"NR_THREADS", NR_THREADS},
124  {"OPS", NUM_OPS},
125  {"NUM_IDX", NUM_IDX},
126  {"NUM_KVP", NUM_KVP},
127  {"RECORD_SIZE", VALUE_SIZE},
128  {"MAX_RSIZE", MAX_VALUE_SIZE},
129  {"GET", GET},
130  {"PUT", PUT},
131  {"POOL_FID", POOL_FID},
132  {"NEXT", NEXT},
133  {"DEL", DEL},
134  {"NXRECORDS", NXRECORDS},
135  {"OP_COUNT", OP_COUNT},
136  {"EXEC_TIME", EXEC_TIME},
137  {"WARMUP_PUT_CNT", WARMUP_PUT_CNT},
138  {"WARMUP_DEL_RATIO", WARMUP_DEL_RATIO},
139  {"KEY_PREFIX", KEY_PREFIX},
140  {"KEY_ORDER", KEY_ORDER},
141  {"KEY_SIZE", KEY_SIZE},
142  {"VALUE_SIZE", VALUE_SIZE},
143  {"MAX_KEY_SIZE", MAX_KEY_SIZE},
144  {"MAX_VALUE_SIZE", MAX_VALUE_SIZE},
145  {"INDEX_FID", INDEX_FID},
146  {"LOG_LEVEL", LOG_LEVEL},
147  {"NR_OBJS", NR_OBJS},
148  {"NR_THREADS", NR_THREADS},
149  {"THREAD_OPS", THREAD_OPS},
150  {"BLOCK_SIZE", BLOCK_SIZE},
151  {"BLOCKS_PER_OP", BLOCKS_PER_OP},
152  {"IOSIZE", IOSIZE},
153  {"SOURCE_FILE", SOURCE_FILE},
154  {"RAND_IO", RAND_IO},
155  {"OPCODE", OPCODE},
156  {"STARTING_OBJ_ID", START_OBJ_ID},
157  {"MODE", MODE},
158  {"MAX_NR_OPS", MAX_NR_OPS},
159  {"NR_ROUNDS", NR_ROUNDS},
160 };
161 
162 #define NKEYS (sizeof(lookuptable)/sizeof(struct key_lookup_table))
163 
164 enum config_key_val get_index_from_key(char *key)
165 {
166  int i;
167  char *s1;
168 
169  for(i = 0; i < NKEYS; i++) {
170  s1 = strstr(key, lookuptable[i].key);
171  if (s1 != NULL && !strcmp(key, lookuptable[i].key)) {
172  return lookuptable[i].index;
173  }
174  }
175  return INVALID_OPT;
176 }
177 
178 const char *get_key_from_index(const enum config_key_val key)
179 {
180  int i;
181  const char *result = NULL;
182 
183  for(i = 0; i < NKEYS; i++) {
184  if (key == lookuptable[i].index) {
185  result = lookuptable[i].key;
186  break;
187  }
188  }
189 
190  return result;
191 }
192 
193 void parser_emit_error(const char *fmt, ...)
194  __attribute__((no_exit))
195  __attribute__((format(printf, 1,2)));
196 
197 void parser_emit_error(const char *fmt, ...)
198 {
199  va_list args;
200  va_start(args, fmt);
201  vfprintf(stderr, fmt, args);
202  fprintf(stderr, "\n");
203  va_end(args);
204  exit(EXIT_FAILURE);
205 }
206 
207 static int parse_int_with_units(const char *value, enum config_key_val tag)
208 {
209  unsigned long long v = getnum(value, get_key_from_index(tag));
210 
211  if (v > INT_MAX)
212  parser_emit_error("Value overflow detected (value=%s, tag=%s", value, get_key_from_index(tag));
213 
214  return v;
215 }
216 
217 static int parse_int(const char *value, enum config_key_val tag)
218 {
219  char *endptr;
220  long val = 0;
221 
222  val = strtol(value, &endptr, 10);
223 
224  if ((val == LONG_MAX || val == LONG_MIN) && errno == ERANGE) {
225  parser_emit_error("Invalid int value (value '%s'='%s', err: %s).\n", get_key_from_index(tag), value, strerror(errno));
226  }
227 
228  if (endptr == value) {
229  parser_emit_error("Value '%s' is not a number\n", value);
230  }
231 
232  return val;
233 }
234 
235 #define SIZEOF_CWIDX sizeof(struct m0_workload_index)
236 #define SIZEOF_CWIO sizeof(struct m0_workload_io)
237 
238 #define workload_index(t) (t->u.cw_index)
239 #define workload_io(t) (t->u.cw_io)
240 
241 const char conf_section_name[] = "MOTR_CONFIG";
242 
243 int copy_value(struct workload *load, int max_workload, int *index,
244  char *key, char *value)
245 {
246  int value_len = strlen(value);
247  struct workload *w = NULL;
248  struct m0_fid *obj_fid;
249  struct m0_workload_io *cw;
250  struct m0_workload_index *ciw;
251 
252  if (m0_streq(value, conf_section_name)) {
253  if (conf != NULL) {
254  cr_log(CLL_ERROR, "YAML file error: "
255  "more than one config sections\n");
256  return -EINVAL;
257  }
258 
259  conf = m0_alloc(sizeof(struct crate_conf));
260  if (conf == NULL)
261  return -ENOMEM;
262  }
263  if (conf == NULL) {
264  cr_log(CLL_ERROR, "YAML file error: %s section is missing\n",
265  conf_section_name);
266  return -EINVAL;
267  }
268 
269  if (get_index_from_key(key) > WORKLOAD_TYPE && *index < 0) {
270  cr_log(CLL_ERROR, "YAML file error: WORKLOAD_TYPE is missing "
271  "or is not going first in the workload section\n");
272  return -EINVAL;
273  }
274 
275  switch(get_index_from_key(key)) {
276  case LOCAL_ADDR:
277  conf->local_addr = m0_alloc(value_len + 1);
278  if (conf->local_addr == NULL)
279  return -ENOMEM;
280  strcpy(conf->local_addr, value);
281  break;
282  case HA_ADDR:
283  conf->ha_addr = m0_alloc(value_len + 1);
284  if (conf->ha_addr == NULL)
285  return -ENOMEM;
286  strcpy(conf->ha_addr, value);
287  break;
288  case PROF:
289  conf->prof = m0_alloc(value_len + 1);
290  if (conf->prof == NULL)
291  return -ENOMEM;
292  strcpy(conf->prof, value);
293  break;
294  case MAX_QUEUE_LEN:
295  conf->tm_recv_queue_min_len = atoi(value);
296  break;
297  case MAX_RPC_MSG:
298  conf->max_rpc_msg_size = atoi(value);
299  break;
300  case PROCESS_FID:
301  conf->process_fid = m0_alloc(value_len + 1);
302  if (conf->process_fid == NULL)
303  return -ENOMEM;
304  strcpy(conf->process_fid, value);
305  break;
306  case LAYOUT_ID:
307  conf->layout_id = atoi(value);
308  break;
309  case IS_OOSTORE:
310  conf->is_oostrore = atoi(value);
311  break;
312  case IS_READ_VERIFY:
313  conf->is_read_verify = atoi(value);
314  break;
315  case IDX_SERVICE_ID:
316  conf->index_service_id = atoi(value);
317  break;
318  case CASS_EP:
319  conf->cass_cluster_ep = m0_alloc(value_len + 1);
320  if (conf->cass_cluster_ep == NULL)
321  return -ENOMEM;
322  strcpy(conf->cass_cluster_ep, value);
323  break;
324  case CASS_KEYSPACE:
325  conf->cass_keyspace = m0_alloc(value_len + 1);
326  if ( conf->cass_keyspace == NULL)
327  return -ENOMEM;
328 
329  strcpy(conf->cass_keyspace, value);
330  break;
331  case CASS_COL_FAMILY:
332  conf->col_family = atoi(value);
333  break;
334  case ADDB_INIT:
335  conf->is_addb_init = atoi(value);
336  break;
337  case ADDB_SIZE:
338  conf->addb_size = getnum(value, "addb size");
339  break;
340  case LOG_LEVEL:
341  conf->log_level = parse_int(value, LOG_LEVEL);
342  break;
343  case WORKLOAD_TYPE:
344  (*index)++;
345  w = &load[*index];
346  if (atoi(value) == INDEX) {
347  w->cw_type = CWT_INDEX;
348  w->u.cw_index = m0_alloc(SIZEOF_CWIDX);
349  if (w->u.cw_io == NULL)
350  return -ENOMEM;
351  } else {
352  w->cw_type = CWT_IO;
353  w->u.cw_io = m0_alloc(SIZEOF_CWIO);
354  if (w->u.cw_io == NULL)
355  return -ENOMEM;
356  }
357  return workload_init(w, w->cw_type);
358  case SEED:
359  w = &load[*index];
360  if (w->cw_type == CWT_IO) {
361  cw = workload_io(w);
362  if (strcmp(value, "tstamp"))
363  w->cw_rstate = atoi(value);
364  } else {
365  ciw = workload_index(w);
366  if (!strcmp(value, "tstamp"))
367  ciw->seed = time(NULL);
368  else
369  ciw->seed = parse_int(value, SEED);
370  }
371  break;
372  case NR_THREADS:
373  w = &load[*index];
374  w->cw_nr_thread = atoi(value);
375  break;
376  case NUM_OPS:
377  w = &load[*index];
378  w->cw_ops = atoi(value);
379  break;
380  case NUM_IDX:
381  w = &load[*index];
382  ciw = workload_index(w);
383  ciw->num_index = atoi(value);
384  break;
385  case NUM_KVP:
386  w = &load[*index];
387  ciw = workload_index(w);
388  ciw->num_kvs = atoi(value);
389  break;
390  case PUT:
391  w = &load[*index];
392  ciw = workload_index(w);
393  ciw->opcode_prcnt[CRATE_OP_PUT] = parse_int(value, PUT);
394  break;
395  case GET:
396  w = &load[*index];
397  ciw = workload_index(w);
398  ciw->opcode_prcnt[CRATE_OP_GET] = parse_int(value, GET);
399  break;
400  case NEXT:
401  w = &load[*index];
402  ciw = workload_index(w);
403  ciw->opcode_prcnt[CRATE_OP_NEXT] = parse_int(value, NEXT);
404  break;
405  case DEL:
406  w = &load[*index];
407  ciw = workload_index(w);
408  ciw->opcode_prcnt[CRATE_OP_DEL] = parse_int(value, DEL);
409  break;
410  case NXRECORDS:
411  w = &load[*index];
412  ciw = workload_index(w);
413  if (!strcmp(value, "default"))
414  ciw->next_records = -1;
415  else
416  ciw->next_records = parse_int_with_units(value, NXRECORDS);
417  break;
418  case OP_COUNT:
419  w = &load[*index];
420  ciw = workload_index(w);
421  if (!strcmp(value, "unlimited"))
422  ciw->op_count = -1;
423  else
424  ciw->op_count = parse_int_with_units(value, OP_COUNT);
425  break;
426  case EXEC_TIME:
427  w = &load[*index];
428  if (w->cw_type == CWT_INDEX) {
429  ciw = workload_index(w);
430  if (!strcmp(value, "unlimited"))
431  ciw->exec_time = -1;
432  else
433  ciw->exec_time = parse_int(value,
434  EXEC_TIME);
435  } else {
436  cw = workload_io(w);
437  if (!strcmp(value, "unlimited"))
438  cw->cwi_execution_time = M0_TIME_NEVER;
439  else
440  cw->cwi_execution_time = m0_time((uint64_t)parse_int(value, EXEC_TIME),
441  (long)0);
442  }
443  break;
444  case KEY_PREFIX:
445  w = &load[*index];
446  ciw = workload_index(w);
447  if (!strcmp(value, "random"))
448  ciw->key_prefix.f_container = -1;
449  else
450  ciw->key_prefix.f_container = parse_int(value, KEY_PREFIX);
451  break;
452  case KEY_ORDER:
453  w = &load[*index];
454  ciw = workload_index(w);
455  if (!strcmp(value, "ordered"))
456  ciw->keys_ordered = true;
457  else if (!strcmp(value, "random"))
458  ciw->keys_ordered = false;
459  else
460  parser_emit_error("Unkown key ordering: '%s'", value);
461  break;
462  case KEY_SIZE:
463  w = &load[*index];
464  ciw = workload_index(w);
465  if (strcmp(value, "random") == 0)
466  ciw->key_size = -1;
467  else
468  ciw->key_size = parse_int(value, KEY_SIZE);
469  break;
470  case VALUE_SIZE:
471  w = &load[*index];
472  ciw = workload_index(w);
473  if (strcmp(value, "random") == 0)
474  ciw->value_size = -1;
475  else {
476  ciw->value_size = parse_int(value, VALUE_SIZE);
477  if (strcmp(key, "RECORD_SIZE") == 0) {
478  cr_log(CLL_WARN, "RECORD_SIZE is being deprecated, use KEY_SIZE and VALUE_SIZE.\n");
479  ciw->value_size = ciw->value_size - ciw->key_size;
480  }
481  }
482  break;
483  case MAX_KEY_SIZE:
484  w = &load[*index];
485  ciw = workload_index(w);
486  ciw->max_key_size = parse_int(value, MAX_KEY_SIZE);
487  break;
488  case MAX_VALUE_SIZE:
489  w = &load[*index];
490  ciw = workload_index(w);
491  ciw->max_value_size = parse_int(value, MAX_VALUE_SIZE);
492  if (strcmp(key, "MAX_RSIZE") == 0) {
493  cr_log(CLL_WARN, "MAX_RSIZE is being deprecated, use MAX_KEY_SIZE and MAX_VALUE_SIZE.\n");
494  ciw->max_value_size = ciw->max_value_size - ciw->max_key_size;
495  }
496  break;
497  case INDEX_FID:
498  w = &load[*index];
499  ciw = workload_index(w);
500  if (0 != m0_fid_sscanf(value, &ciw->index_fid)) {
501  parser_emit_error("Unable to parse fid: %s", value);
502  }
503  break;
504  case WARMUP_PUT_CNT:
505  w = &load[*index];
506  ciw = workload_index(w);
507  if (!strcmp(value, "all"))
508  ciw->warmup_put_cnt = -1;
509  else
510  ciw->warmup_put_cnt = parse_int(value, WARMUP_PUT_CNT);
511  break;
512  case WARMUP_DEL_RATIO:
513  w = &load[*index];
514  ciw = workload_index(w);
515  ciw->warmup_del_ratio = parse_int(value, WARMUP_DEL_RATIO);
516  break;
517  case THREAD_OPS:
518  w = &load[*index];
519  cw = workload_io(w);
520  cw->cwi_share_object = atoi(value);
521  break;
522  case BLOCK_SIZE:
523  w = &load[*index];
524  cw = workload_io(w);
525  cw->cwi_bs = getnum(value, "block size");
526  break;
527  case BLOCKS_PER_OP:
528  w = &load[*index];
529  cw = workload_io(w);
530  cw->cwi_bcount_per_op = atol(value);
531  break;
532  case NR_OBJS:
533  w = &load[*index];
534  cw = workload_io(w);
535  cw->cwi_nr_objs = atoi(value);
536  break;
537  case MAX_NR_OPS:
538  w = &load[*index];
539  cw = workload_io(w);
540  cw->cwi_max_nr_ops = atoi(value);
541  break;
542  case IOSIZE:
543  w = &load[*index];
544  cw = workload_io(w);
545  cw->cwi_io_size = getnum(value, "io size");
546  break;
547  case SOURCE_FILE:
548  w = &load[*index];
549  cw = workload_io(w);
550  cw->cwi_filename = m0_alloc(value_len + 1);
551  strcpy(cw->cwi_filename, value);
552  break;
553  case RAND_IO:
554  w = &load[*index];
555  cw = workload_io(w);
556  cw->cwi_random_io = atoi(value);
557  break;
558  case POOL_FID:
559  w = &load[*index];
560  cw = workload_io(w);
561  if (0 != m0_fid_sscanf(value, &cw->cwi_pool_id)) {
562  parser_emit_error("Unable to parse fid: %s", value);
563  }
564  break;
565  case OPCODE:
566  w = &load[*index];
567  cw = workload_io(w);
568  cw->cwi_opcode = atoi(value);
569  if (conf->layout_id <= 0) {
570  cr_log(CLL_ERROR, "LAYOUT_ID is not set\n");
571  return -EINVAL;
572  }
573  cw->cwi_layout_id = conf->layout_id;
574  break;
575  case START_OBJ_ID:
576  w = &load[*index];
577  cw = workload_io(w);
578  cw->cwi_start_obj_id = M0_ID_APP;
579  if (strchr(value, ':') == NULL) {
580  cw->cwi_start_obj_id.u_lo = atoi(value);
581  break;
582  }
583  obj_fid = (struct m0_fid *)&cw->cwi_start_obj_id;
584  m0_fid_sscanf(value, obj_fid);
585  break;
586  case MODE:
587  w = &load[*index];
588  cw = workload_io(w);
589  cw->cwi_mode = atoi(value);
590  break;
591  case NR_ROUNDS:
592  w = &load[*index];
593  cw = workload_io(w);
594  cw->cwi_rounds = atoi(value);
595  break;
596  default:
597  break;
598  }
599  return 0;
600 }
601 
602 int parse_yaml_file(struct workload *load, int max_workload, int *index,
603  char *config_file)
604 {
605  FILE *fh;
606  int is_key = 0;
607  char key[MAX_KEY_LEN];
608  char *scalar_value;
609  int rc;
610 
611  yaml_parser_t parser;
612  yaml_token_t token;
613 
614  if (!yaml_parser_initialize(&parser)) {
615  cr_log(CLL_ERROR, "Failed to initialize parser!\n");
616  return -1;
617  }
618 
619  fh = fopen(config_file, "r");
620  if (fh == NULL) {
621  cr_log(CLL_ERROR, "Failed to open file!\n");
622  yaml_parser_delete(&parser);
623  return -1;
624  }
625 
626  yaml_parser_set_input_file(&parser, fh);
627 
628  do {
629  rc = 0;
630  yaml_parser_scan(&parser, &token);
631  switch (token.type) {
632  case YAML_KEY_TOKEN:
633  is_key = 1;
634  break;
635  case YAML_VALUE_TOKEN:
636  is_key = 0;
637  break;
638  case YAML_SCALAR_TOKEN:
639  scalar_value = (char *)token.data.scalar.value;
640  if (is_key) {
641  strcpy(key, scalar_value);
642  } else {
643  rc = copy_value(load, max_workload, index,
644  key, scalar_value);
645  }
646  break;
647  case YAML_NO_TOKEN:
648  rc = -EINVAL;
649  break;
650  default:
651  break;
652  }
653 
654  if (rc != 0) {
655  cr_log(CLL_ERROR, "Failed to parse %s\n", key);
656  yaml_token_delete(&token);
657  yaml_parser_delete(&parser);
658  fclose(fh);
659  return rc;
660  }
661 
662  if (token.type != YAML_STREAM_END_TOKEN)
663  yaml_token_delete(&token);
664 
665  } while (token.type != YAML_STREAM_END_TOKEN);
666 
667  yaml_token_delete(&token);
668  yaml_parser_delete(&parser);
669  fclose(fh);
670  return 0;
671 }
672 
673 /*
674  * Local variables:
675  * c-indentation-style: "K&R"
676  * c-basic-offset: 8
677  * tab-width: 8
678  * fill-column: 80
679  * scroll-step: 1
680  * End:
681  */
682 /*
683  * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
684  */
m0_workload_index::max_key_size
int max_key_size
Definition: crate_client.h:107
hist.load
def load()
Definition: hist.py:112
CRATE_OP_PUT
Definition: crate_client.h:66
workload::cw_index
void * cw_index
Definition: workload.h:99
RAND_IO
Definition: parser.c:92
m0_workload_io::cwi_rounds
uint32_t cwi_rounds
Definition: crate_client.h:175
CWT_INDEX
Definition: workload.h:58
NULL
#define NULL
Definition: misc.h:38
m0_workload_io::cwi_nr_objs
int32_t cwi_nr_objs
Definition: crate_client.h:174
val
Definition: idx_mock.c:52
m0_workload_index::exec_time
int exec_time
Definition: crate_client.h:94
M0_TIME_NEVER
const m0_time_t M0_TIME_NEVER
Definition: time.c:108
CWT_IO
Definition: workload.h:57
tag
static uint64_t tag(uint8_t code, uint64_t id)
Definition: addb2.c:1047
parse_int_with_units
static int parse_int_with_units(const char *value, enum config_key_val tag)
Definition: parser.c:207
m0_workload_index::keys_ordered
bool keys_ordered
Definition: crate_client.h:111
m0_workload_io::cwi_bs
uint64_t cwi_bs
Definition: crate_client.h:163
PUT
Definition: parser.c:71
CLL_WARN
Definition: logger.h:39
m0_workload_index::index_fid
struct m0_fid index_fid
Definition: crate_client.h:113
value
int const char const void * value
Definition: dir.c:325
key_lookup_table
Definition: parser.c:100
m0_workload_index::key_prefix
struct m0_fid key_prefix
Definition: crate_client.h:101
CASS_EP
Definition: parser.c:52
INDEX
Definition: crate_client.h:61
__attribute__
enum m0_md_lustre_logrec_type __attribute__
Definition: balloc.c:2745
conf
Definition: conf.py:1
m0_workload_io::cwi_filename
char * cwi_filename
Definition: crate_client.h:184
CRATE_OP_DEL
Definition: crate_client.h:69
NR_OBJS
Definition: parser.c:68
m0_workload_io::cwi_opcode
int32_t cwi_opcode
Definition: crate_client.h:178
args
Definition: ub.c:49
m0_workload_index::opcode_prcnt
int opcode_prcnt[CRATE_OP_TYPES]
Definition: crate_client.h:83
OPCODE
Definition: parser.c:93
m0_time
m0_time_t m0_time(uint64_t secs, long ns)
Definition: time.c:41
copy_value
int copy_value(struct workload *load, int max_workload, int *index, char *key, char *value)
Definition: parser.c:243
NUM_OPS
Definition: parser.c:67
workload::cw_rstate
unsigned cw_rstate
Definition: workload.h:79
key_lookup_table::index
enum config_key_val index
Definition: parser.c:102
getnum
unsigned long long getnum(const char *str, const char *msg)
Definition: crate_utils.c:222
M0_ID_APP
const struct m0_uint128 M0_ID_APP
Definition: client.c:92
get_index_from_key
enum config_key_val get_index_from_key(char *key)
Definition: parser.c:164
cr_kvs_key_len_max
cr_kvs_key_len_max
Definition: parser.c:32
workload::cw_ops
unsigned cw_ops
Definition: workload.h:76
workload::u
union workload::@328 u
i
int i
Definition: dir.c:1033
error_injection.fh
fh
Definition: error_injection.py:34
m0_workload_io::cwi_bcount_per_op
uint32_t cwi_bcount_per_op
Definition: crate_client.h:168
addb2db.args
def args
Definition: addb2db.py:716
workload::cw_io
void * cw_io
Definition: workload.h:98
m0_workload_index::num_index
int num_index
Definition: crate_client.h:79
workload_type_ops
Definition: workload.h:168
conf
struct crate_conf * conf
Definition: crate_client_utils.c:38
if
if(value==NULL)
Definition: dir.c:350
GET
Definition: parser.c:72
m0_workload_index::seed
uint64_t seed
Definition: crate_client.h:115
conf_section_name
const char conf_section_name[]
Definition: parser.c:241
m0_workload_index::op_count
int op_count
Definition: crate_client.h:89
m0_streq
#define m0_streq(a, b)
Definition: string.h:34
parser_emit_error
void parser_emit_error(const char *fmt,...) __attribute__((no_exit)) __attribute__((format(printf
Definition: parser.c:197
crate_client.h
NKEYS
#define NKEYS
Definition: parser.c:162
config_key_val
config_key_val
Definition: parser.c:40
queues.parser
parser
Definition: queues.py:206
m0_workload_index::max_value_size
int max_value_size
Definition: crate_client.h:108
CRATE_OP_NEXT
Definition: crate_client.h:68
fmt
char * fmt(const char *format,...) __attribute__((format(printf
m0_alloc
void * m0_alloc(size_t size)
Definition: memory.c:126
m0_fid::f_container
uint64_t f_container
Definition: fid.h:39
SEED
Definition: parser.c:65
token
static void token(struct ff2c_context *ctx, struct ff2c_term *term, struct ff2c_token *tok)
Definition: parser.c:66
m0_workload_io::cwi_pool_id
struct m0_fid cwi_pool_id
Definition: crate_client.h:169
MODE
Definition: parser.c:95
workload_index
#define workload_index(t)
Definition: parser.c:238
m0_fid_sscanf
M0_INTERNAL int m0_fid_sscanf(const char *s, struct m0_fid *fid)
Definition: fid.c:227
NEXT
Definition: parser.c:73
parse_yaml_file
int parse_yaml_file(struct workload *load, int max_workload, int *index, char *config_file)
Definition: parser.c:602
m0_workload_io::cwi_mode
int32_t cwi_mode
Definition: crate_client.h:173
workload::cw_nr_thread
unsigned cw_nr_thread
Definition: workload.h:78
SIZEOF_CWIO
#define SIZEOF_CWIO
Definition: parser.c:236
m0_workload_io::cwi_share_object
bool cwi_share_object
Definition: crate_client.h:177
key_lookup_table::key
char * key
Definition: parser.c:101
hist.format
format
Definition: hist.py:128
m0_workload_index::warmup_del_ratio
int warmup_del_ratio
Definition: crate_client.h:99
NUM_IDX
Definition: parser.c:69
index_ops
struct workload_type_ops index_ops
m0_workload_index::num_kvs
int num_kvs
Definition: crate_client.h:80
m0_workload_index
Definition: crate_client.h:76
m0_fid
Definition: fid.h:38
SIZEOF_CWIDX
#define SIZEOF_CWIDX
Definition: parser.c:235
m0_workload_io::cwi_start_obj_id
struct m0_uint128 cwi_start_obj_id
Definition: crate_client.h:179
m0_workload_io::cwi_max_nr_ops
uint32_t cwi_max_nr_ops
Definition: crate_client.h:172
m0_workload_io
Definition: crate_client.h:158
workload_init
static void workload_init(struct sim *s, int argc, char **argv)
Definition: m0t1fs_test.c:99
parse_int
static int parse_int(const char *value, enum config_key_val tag)
Definition: parser.c:217
HA_ADDR
Definition: parser.c:43
crate_conf
Definition: crate_client.h:39
m0_workload_index::warmup_put_cnt
int warmup_put_cnt
Definition: crate_client.h:97
cr_log
void cr_log(enum cr_log_level lev, const char *fmt,...)
Definition: logger.c:39
NUM_KVP
Definition: parser.c:70
CRATE_OP_GET
Definition: crate_client.h:67
DEL
Definition: parser.c:74
workload::cw_type
enum cr_workload_type cw_type
Definition: workload.h:74
CLL_ERROR
Definition: logger.h:38
m0_workload_io::cwi_layout_id
uint32_t cwi_layout_id
Definition: crate_client.h:161
m0_workload_io::cwi_io_size
uint64_t cwi_io_size
Definition: crate_client.h:170
lookuptable
struct key_lookup_table lookuptable[]
Definition: parser.c:105
m0_workload_index::next_records
int next_records
Definition: crate_client.h:84
PROF
Definition: parser.c:44
ops
struct workload_type_ops ops
Definition: io_foms.c:623
m0_uint128::u_lo
uint64_t u_lo
Definition: types.h:37
m0_workload_index::key_size
int key_size
Definition: crate_client.h:105
IOSIZE
Definition: parser.c:90
workload_io
#define workload_io(t)
Definition: parser.c:239
m0_workload_io::cwi_random_io
bool cwi_random_io
Definition: crate_client.h:176
rc
int32_t rc
Definition: trigger_fop.h:47
get_key_from_index
const char * get_key_from_index(const enum config_key_val key)
Definition: parser.c:178
m0_workload_io::cwi_execution_time
m0_time_t cwi_execution_time
Definition: crate_client.h:182
key
Definition: idx_mock.c:47
m0_workload_index::value_size
int value_size
Definition: crate_client.h:106