int main(int argc, char **argv)
{
rocksdb_t *db;
rocksdb_backup_engine_t *be;
rocksdb_options_t *options = rocksdb_options_create();
// Optimize RocksDB. This is the easiest way to
// get RocksDB to perform well
long cpus = sysconf(_SC_NPROCESSORS_ONLN); // get # of online cores
rocksdb_options_increase_parallelism(options, (int)(cpus));
rocksdb_options_optimize_level_style_compaction(options, 0);
// create the DB if it's not already present
rocksdb_options_set_create_if_missing(options, 1);
// open DB
char *err = NULL;
db = rocksdb_open(options, DBPath, &err);
assert(!err);
// open Backup Engine that we will use for backing up our database
be = rocksdb_backup_engine_open(options, DBBackupPath, &err);
assert(!err);
// Put key-value
rocksdb_writeoptions_t *writeoptions = rocksdb_writeoptions_create();
const char key[] = "key";
const char *value = "value";
rocksdb_put(db, writeoptions, key, strlen(key), value, strlen(value) + 1,
&err);
assert(!err);
// Get value
rocksdb_readoptions_t *readoptions = rocksdb_readoptions_create();
size_t len;
char *returned_value =
rocksdb_get(db, readoptions, key, strlen(key), &len, &err);
assert(!err);
assert(strcmp(returned_value, "value") == 0);
free(returned_value);
// create new backup in a directory specified by DBBackupPath
rocksdb_backup_engine_create_new_backup(be, db, &err);
assert(!err);
rocksdb_close(db);
// If something is wrong, you might want to restore data from last backup
rocksdb_restore_options_t *restore_options = rocksdb_restore_options_create();
rocksdb_backup_engine_restore_db_from_latest_backup(be, DBPath, DBPath,
restore_options, &err);
assert(!err);
rocksdb_restore_options_destroy(restore_options);
db = rocksdb_open(options, DBPath, &err);
assert(!err);
// cleanup
rocksdb_writeoptions_destroy(writeoptions);
rocksdb_readoptions_destroy(readoptions);
rocksdb_options_destroy(options);
rocksdb_backup_engine_close(be);
rocksdb_close(db);
return 0;
}
int main(int argc, char **argv) {
rocksdb_t *db;
rocksdb_backup_engine_t *be;
rocksdb_options_t *options = rocksdb_options_create();
// Optimize RocksDB. This is the easiest way to
// get RocksDB to perform well
long cpus = sysconf(_SC_NPROCESSORS_ONLN); // get # of online cores
rocksdb_options_increase_parallelism(options, (int)(cpus));
rocksdb_options_optimize_level_style_compaction(options, 0);
rocksdb_options_set_max_open_files(options, 1000);
// create the DB if it's not already present
rocksdb_options_set_create_if_missing(options, 1);
/*
enum {
rocksdb_no_compression = 0,
rocksdb_snappy_compression = 1,
rocksdb_zlib_compression = 2,
rocksdb_bz2_compression = 3,
rocksdb_lz4_compression = 4,
rocksdb_lz4hc_compression = 5
};
*/
rocksdb_options_set_compression(options, 1);
//rocksdb_options_set_write_buffer_size(options, 1024 * 1024 * 1024 * 1024);
rocksdb_options_set_write_buffer_size(options, 256 * 1024 * 1024);
rocksdb_options_set_max_write_buffer_number(options, 2);
rocksdb_options_set_target_file_size_base(options, 256 * 1024 * 1024);
rocksdb_options_set_target_file_size_multiplier(options, 1);
rocksdb_options_set_max_bytes_for_level_base(options, 1024 * 1024 * 1024);
rocksdb_options_set_max_bytes_for_level_multiplier(options, 4);
rocksdb_options_set_num_levels(options, 6);
rocksdb_options_set_max_background_flushes(options, 0);
rocksdb_options_set_max_background_compactions(options, 4);
rocksdb_options_set_hard_rate_limit(options, 2);
rocksdb_options_set_max_log_file_size(options, 1024 * 1024 * 1024 * 1024);
rocksdb_options_set_keep_log_file_num(options, 25);
rocksdb_options_set_allow_mmap_reads(options, 1);
rocksdb_options_set_allow_mmap_writes(options, 0);
rocksdb_options_set_disable_data_sync(options, 1);
rocksdb_options_set_level0_file_num_compaction_trigger(options, 8);
rocksdb_options_set_delete_obsolete_files_period_micros(options, 314572800);
rocksdb_options_set_max_grandparent_overlap_factor(options, 10);
rocksdb_options_set_level0_slowdown_writes_trigger(options, 16);
rocksdb_options_set_level0_stop_writes_trigger(options, 24);
// open DB
char *err = NULL;
db = rocksdb_open(options, DBPath, &err);
assert(!err);
// write a million entries
int i = 0;
printf("testing .... \n");
rocksdb_writeoptions_t *writeoptions = rocksdb_writeoptions_create();
rocksdb_writeoptions_set_sync(writeoptions, 0);
rocksdb_writeoptions_disable_WAL(writeoptions, 0);
for (i = 0; i< 1000000; i++) {
//printf("%d",i);
// Put key-value
const char key[8];
sprintf(key, "%d", i);
printf("key:%s \n", key);
const char *value = NULL;
value = &key;
printf("value:%c, value_size:%d\n", *value, strlen(value) + 1);
printf("putting... \n");
rocksdb_put(db, writeoptions, key, strlen(key), value, strlen(value) + 1,
&err);
printf("end of putting \n");
printf(err);
assert(!err);
}
// cleanup
rocksdb_close(db);
rocksdb_writeoptions_destroy(writeoptions);
rocksdb_options_destroy(options);
return 0;
}
