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