ceph/src/rocksdb/java/rocksjni/sst_file_manager.cc

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5 //
   6 // This file implements the "bridge" between Java and C++ and enables
   7 // calling C++ rocksdb::SstFileManager methods
   8 // from Java side.
   9
  10 #include <jni.h>
  11 #include <memory>
  12
  13 #include "include/org_rocksdb_SstFileManager.h"
  14 #include "rocksdb/sst_file_manager.h"
  15 #include "rocksjni/portal.h"
  16
  17 /*
  18  * Class:     org_rocksdb_SstFileManager
  19  * Method:    newSstFileManager
  20  * Signature: (JJJDJ)J
  21  */
  22 jlong Java_org_rocksdb_SstFileManager_newSstFileManager(
  23     JNIEnv* jnienv, jclass /*jcls*/, jlong jenv_handle, jlong jlogger_handle,
  24     jlong jrate_bytes, jdouble jmax_trash_db_ratio,
  25     jlong jmax_delete_chunk_bytes) {
  26   auto* env = reinterpret_cast<rocksdb::Env*>(jenv_handle);
  27   rocksdb::Status s;
  28   rocksdb::SstFileManager* sst_file_manager = nullptr;
  29
  30   if (jlogger_handle != 0) {
  31     auto* sptr_logger =
  32         reinterpret_cast<std::shared_ptr<rocksdb::Logger>*>(jlogger_handle);
  33     sst_file_manager = rocksdb::NewSstFileManager(
  34         env, *sptr_logger, "", jrate_bytes, true, &s, jmax_trash_db_ratio,
  35         jmax_delete_chunk_bytes);
  36   } else {
  37     sst_file_manager = rocksdb::NewSstFileManager(env, nullptr, "", jrate_bytes,
  38                                                   true, &s, jmax_trash_db_ratio,
  39                                                   jmax_delete_chunk_bytes);
  40   }
  41
  42   if (!s.ok()) {
  43     if (sst_file_manager != nullptr) {
  44       delete sst_file_manager;
  45     }
  46     rocksdb::RocksDBExceptionJni::ThrowNew(jnienv, s);
  47   }
  48   auto* sptr_sst_file_manager =
  49       new std::shared_ptr<rocksdb::SstFileManager>(sst_file_manager);
  50
  51   return reinterpret_cast<jlong>(sptr_sst_file_manager);
  52 }
  53
  54 /*
  55  * Class:     org_rocksdb_SstFileManager
  56  * Method:    setMaxAllowedSpaceUsage
  57  * Signature: (JJ)V
  58  */
  59 void Java_org_rocksdb_SstFileManager_setMaxAllowedSpaceUsage(
  60     JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle,
  61     jlong jmax_allowed_space) {
  62   auto* sptr_sst_file_manager =
  63       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
  64   sptr_sst_file_manager->get()->SetMaxAllowedSpaceUsage(jmax_allowed_space);
  65 }
  66
  67 /*
  68  * Class:     org_rocksdb_SstFileManager
  69  * Method:    setCompactionBufferSize
  70  * Signature: (JJ)V
  71  */
  72 void Java_org_rocksdb_SstFileManager_setCompactionBufferSize(
  73     JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle,
  74     jlong jcompaction_buffer_size) {
  75   auto* sptr_sst_file_manager =
  76       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
  77   sptr_sst_file_manager->get()->SetCompactionBufferSize(
  78       jcompaction_buffer_size);
  79 }
  80
  81 /*
  82  * Class:     org_rocksdb_SstFileManager
  83  * Method:    isMaxAllowedSpaceReached
  84  * Signature: (J)Z
  85  */
  86 jboolean Java_org_rocksdb_SstFileManager_isMaxAllowedSpaceReached(
  87     JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) {
  88   auto* sptr_sst_file_manager =
  89       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
  90   return sptr_sst_file_manager->get()->IsMaxAllowedSpaceReached();
  91 }
  92
  93 /*
  94  * Class:     org_rocksdb_SstFileManager
  95  * Method:    isMaxAllowedSpaceReachedIncludingCompactions
  96  * Signature: (J)Z
  97  */
  98 jboolean
  99 Java_org_rocksdb_SstFileManager_isMaxAllowedSpaceReachedIncludingCompactions(
 100     JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) {
 101   auto* sptr_sst_file_manager =
 102       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 103   return sptr_sst_file_manager->get()
 104       ->IsMaxAllowedSpaceReachedIncludingCompactions();
 105 }
 106
 107 /*
 108  * Class:     org_rocksdb_SstFileManager
 109  * Method:    getTotalSize
 110  * Signature: (J)J
 111  */
 112 jlong Java_org_rocksdb_SstFileManager_getTotalSize(JNIEnv* /*env*/,
 113                                                    jobject /*jobj*/,
 114                                                    jlong jhandle) {
 115   auto* sptr_sst_file_manager =
 116       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 117   return sptr_sst_file_manager->get()->GetTotalSize();
 118 }
 119
 120 /*
 121  * Class:     org_rocksdb_SstFileManager
 122  * Method:    getTrackedFiles
 123  * Signature: (J)Ljava/util/Map;
 124  */
 125 jobject Java_org_rocksdb_SstFileManager_getTrackedFiles(JNIEnv* env,
 126                                                         jobject /*jobj*/,
 127                                                         jlong jhandle) {
 128   auto* sptr_sst_file_manager =
 129       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 130   auto tracked_files = sptr_sst_file_manager->get()->GetTrackedFiles();
 131
 132   //TODO(AR) could refactor to share code with rocksdb::HashMapJni::fromCppMap(env, tracked_files);
 133
 134   const jobject jtracked_files = rocksdb::HashMapJni::construct(
 135       env, static_cast<uint32_t>(tracked_files.size()));
 136   if (jtracked_files == nullptr) {
 137     // exception occurred
 138     return nullptr;
 139   }
 140
 141   const rocksdb::HashMapJni::FnMapKV<const std::string, const uint64_t, jobject, jobject>
 142       fn_map_kv =
 143           [env](const std::pair<const std::string, const uint64_t>& pair) {
 144             const jstring jtracked_file_path =
 145                 env->NewStringUTF(pair.first.c_str());
 146             if (jtracked_file_path == nullptr) {
 147               // an error occurred
 148               return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
 149             }
 150             const jobject jtracked_file_size =
 151                 rocksdb::LongJni::valueOf(env, pair.second);
 152             if (jtracked_file_size == nullptr) {
 153               // an error occurred
 154               return std::unique_ptr<std::pair<jobject, jobject>>(nullptr);
 155             }
 156             return std::unique_ptr<std::pair<jobject, jobject>>(
 157                 new std::pair<jobject, jobject>(jtracked_file_path,
 158                                                 jtracked_file_size));
 159           };
 160
 161   if (!rocksdb::HashMapJni::putAll(env, jtracked_files, tracked_files.begin(),
 162                                    tracked_files.end(), fn_map_kv)) {
 163     // exception occcurred
 164     return nullptr;
 165   }
 166
 167   return jtracked_files;
 168 }
 169
 170 /*
 171  * Class:     org_rocksdb_SstFileManager
 172  * Method:    getDeleteRateBytesPerSecond
 173  * Signature: (J)J
 174  */
 175 jlong Java_org_rocksdb_SstFileManager_getDeleteRateBytesPerSecond(
 176     JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle) {
 177   auto* sptr_sst_file_manager =
 178       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 179   return sptr_sst_file_manager->get()->GetDeleteRateBytesPerSecond();
 180 }
 181
 182 /*
 183  * Class:     org_rocksdb_SstFileManager
 184  * Method:    setDeleteRateBytesPerSecond
 185  * Signature: (JJ)V
 186  */
 187 void Java_org_rocksdb_SstFileManager_setDeleteRateBytesPerSecond(
 188     JNIEnv* /*env*/, jobject /*jobj*/, jlong jhandle, jlong jdelete_rate) {
 189   auto* sptr_sst_file_manager =
 190       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 191   sptr_sst_file_manager->get()->SetDeleteRateBytesPerSecond(jdelete_rate);
 192 }
 193
 194 /*
 195  * Class:     org_rocksdb_SstFileManager
 196  * Method:    getMaxTrashDBRatio
 197  * Signature: (J)D
 198  */
 199 jdouble Java_org_rocksdb_SstFileManager_getMaxTrashDBRatio(JNIEnv* /*env*/,
 200                                                            jobject /*jobj*/,
 201                                                            jlong jhandle) {
 202   auto* sptr_sst_file_manager =
 203       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 204   return sptr_sst_file_manager->get()->GetMaxTrashDBRatio();
 205 }
 206
 207 /*
 208  * Class:     org_rocksdb_SstFileManager
 209  * Method:    setMaxTrashDBRatio
 210  * Signature: (JD)V
 211  */
 212 void Java_org_rocksdb_SstFileManager_setMaxTrashDBRatio(JNIEnv* /*env*/,
 213                                                         jobject /*jobj*/,
 214                                                         jlong jhandle,
 215                                                         jdouble jratio) {
 216   auto* sptr_sst_file_manager =
 217       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 218   sptr_sst_file_manager->get()->SetMaxTrashDBRatio(jratio);
 219 }
 220
 221 /*
 222  * Class:     org_rocksdb_SstFileManager
 223  * Method:    disposeInternal
 224  * Signature: (J)V
 225  */
 226 void Java_org_rocksdb_SstFileManager_disposeInternal(JNIEnv* /*env*/,
 227                                                      jobject /*jobj*/,
 228                                                      jlong jhandle) {
 229   auto* sptr_sst_file_manager =
 230       reinterpret_cast<std::shared_ptr<rocksdb::SstFileManager>*>(jhandle);
 231   delete sptr_sst_file_manager;
 232 }