be/src/util/jni-util.cpp - doris - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.

 #include "util/jni-util.h"

 #include <fmt/format.h>
 #include <glog/logging.h>
 #include <jni.h>
 #include <jni_md.h>

 #include <cstdlib>
 #include <filesystem>
 #include <iterator>
 #include <memory>
 #include <mutex>
 #include <sstream>
 #include <string>
 #include <vector>

 #include "absl/strings/substitute.h"
 #include "common/cast_set.h"
 #include "common/config.h"
 #include "util/doris_metrics.h"
 #include "util/jni_native_method.h"
 // #include "util/libjvm_loader.h"

 using std::string;

 namespace doris {
 #include "common/compile_check_begin.h"
 namespace Jni {
 JavaVM* g_vm;
 [[maybe_unused]] std::once_flag g_vm_once;
 [[maybe_unused]] std::once_flag g_jvm_conf_once;
 __thread JNIEnv* Env::tls_env_ = nullptr;
 jclass Env::jni_util_cl_ = nullptr;
 jmethodID Env::throwable_to_string_id_ = nullptr;
 jmethodID Env::throwable_to_stack_trace_id_ = nullptr;

 const std::string GetDorisJNIDefaultClasspath() {
     const auto* doris_home = getenv("DORIS_HOME");
     DCHECK(doris_home) << "Environment variable DORIS_HOME is not set.";

     std::ostringstream out;

     auto add_jars_from_path = [&](const std::string& base_path) {
         if (!std::filesystem::exists(base_path)) {
             return;
         }
         for (const auto& entry : std::filesystem::recursive_directory_iterator(base_path)) {
             if (entry.path().extension() == ".jar") {
                 if (!out.str().empty()) {
                     out << ":";
                 }
                 out << entry.path().string();
             }
         }
     };

     add_jars_from_path(std::string(doris_home) + "/lib");
     add_jars_from_path(std::string(doris_home) + "/custom_lib");

     // Check and add HADOOP_CONF_DIR if it's set
     const auto* hadoop_conf_dir = getenv("HADOOP_CONF_DIR");
     if (hadoop_conf_dir != nullptr && strlen(hadoop_conf_dir) > 0) {
         if (!out.str().empty()) {
             out << ":";
         }
         out << hadoop_conf_dir;
     }

     DCHECK(!out.str().empty()) << "Empty classpath is invalid.";
     return out.str();
 }

 const std::string GetDorisJNIClasspathOption() {
     const auto* classpath = getenv("DORIS_CLASSPATH");
     if (classpath) {
         return classpath;
     } else {
         return "-Djava.class.path=" + GetDorisJNIDefaultClasspath();
     }
 }

 const std::string GetKerb5ConfPath() {
     return "-Djava.security.krb5.conf=" + config::kerberos_krb5_conf_path;
 }

 [[maybe_unused]] void SetEnvIfNecessary() {
     std::string libhdfs_opts = getenv("LIBHDFS_OPTS") ? getenv("LIBHDFS_OPTS") : "";
     CHECK(libhdfs_opts != "") << "LIBHDFS_OPTS is not set";
     libhdfs_opts += fmt::format(" {} ", GetKerb5ConfPath());
     libhdfs_opts += fmt::format(" -Djdk.lang.processReaperUseDefaultStackSize={}",
                                 config::jdk_process_reaper_use_default_stack_size);
     setenv("LIBHDFS_OPTS", libhdfs_opts.c_str(), 1);
     LOG(INFO) << "set final LIBHDFS_OPTS: " << libhdfs_opts;
 }

 // Only used on non-x86 platform
 [[maybe_unused]] void FindOrCreateJavaVM() {
     int num_vms;
     int rv = JNI_GetCreatedJavaVMs(&g_vm, 1, &num_vms);
     if (rv == 0) {
         std::vector<std::string> options;

         char* java_opts = getenv("JAVA_OPTS");
         if (java_opts == nullptr) {
             options = {
                     GetDorisJNIClasspathOption(), fmt::format("-Xmx{}", "1g"),
                     fmt::format("-DlogPath={}/log/jni.log", getenv("DORIS_HOME")),
                     fmt::format("-Dsun.java.command={}", "DorisBE"), "-XX:-CriticalJNINatives",
                     fmt::format("-Djdk.lang.processReaperUseDefaultStackSize={}",
                                 config::jdk_process_reaper_use_default_stack_size),
 #ifdef __APPLE__
                     // On macOS, we should disable MaxFDLimit, otherwise the RLIMIT_NOFILE
                     // will be assigned the minimum of OPEN_MAX (10240) and rlim_cur (See src/hotspot/os/bsd/os_bsd.cpp)
                     // and it can not pass the check performed by storage engine.
                     // The newer JDK has fixed this issue.
                     "-XX:-MaxFDLimit"
 #endif
             };
         } else {
             std::istringstream stream(java_opts);
             options = std::vector<std::string>(std::istream_iterator<std::string> {stream},
                                                std::istream_iterator<std::string>());
             options.push_back(GetDorisJNIClasspathOption());
         }
         options.push_back(GetKerb5ConfPath());
         std::unique_ptr<JavaVMOption[]> jvm_options(new JavaVMOption[options.size()]);
         for (int i = 0; i < options.size(); ++i) {
             // To convert a string to a char*, const_cast is used.
             jvm_options[i] = {const_cast<char*>(options[i].c_str()), nullptr};
         }

         JNIEnv* env = nullptr;
         JavaVMInitArgs vm_args;
         vm_args.version = JNI_VERSION_1_8;
         vm_args.options = jvm_options.get();
         vm_args.nOptions = cast_set<int>(options.size());
         // Set it to JNI_FALSE because JNI_TRUE will let JVM ignore the max size config.
         vm_args.ignoreUnrecognized = JNI_FALSE;

         jint res = JNI_CreateJavaVM(&g_vm, (void**)&env, &vm_args);
         if (JNI_OK != res) {
             DCHECK(false) << "Failed to create JVM, code= " << res;
         }

     } else {
         CHECK_EQ(rv, 0) << "Could not find any created Java VM";
         CHECK_EQ(num_vms, 1) << "No VMs returned";
     }
 }

 Status Env::GetJNIEnvSlowPath(JNIEnv** env) {
     DCHECK(!tls_env_) << "Call GetJNIEnv() fast path";

 #ifdef USE_LIBHDFS3
     std::call_once(g_vm_once, FindOrCreateJavaVM);
     int rc = g_vm->GetEnv(reinterpret_cast<void**>(&tls_env_), JNI_VERSION_1_8);
     if (rc == JNI_EDETACHED) {
         rc = g_vm->AttachCurrentThread((void**)&tls_env_, nullptr);
     }
     if (rc != 0 || tls_env_ == nullptr) {
         return Status::JniError("Unable to get JVM: {}", rc);
     }
 #else
     // the hadoop libhdfs will do all the stuff
     std::call_once(g_jvm_conf_once, SetEnvIfNecessary);
     tls_env_ = getJNIEnv();
 #endif
     *env = tls_env_;
     return Status::OK();
 }

 Status Env::GetJniExceptionMsg(JNIEnv* env, bool log_stack, const string& prefix) {
     jthrowable exc = env->ExceptionOccurred();
     Defer def {[&]() { env->DeleteLocalRef(exc); }};
     if (exc == nullptr) {
         return Status::OK();
     }
     env->ExceptionClear();
     DCHECK(throwable_to_string_id_ != nullptr);
     const char* oom_msg_template =
             "$0 threw an unchecked exception. The JVM is likely out "
             "of memory (OOM).";
     jstring msg = static_cast<jstring>(
             env->CallStaticObjectMethod(jni_util_cl_, throwable_to_string_id_, exc));
     if (env->ExceptionOccurred()) {
         env->ExceptionClear();
         string oom_msg = absl::Substitute(oom_msg_template, "throwableToString");
         LOG(WARNING) << oom_msg;
         return Status::JniError(oom_msg);
     }

     std::string return_msg;
     auto* msg_str = env->GetStringUTFChars(msg, nullptr);
     return_msg += msg_str;
     env->ReleaseStringUTFChars((jstring)msg, msg_str);

     if (log_stack) {
         jstring stack = static_cast<jstring>(
                 env->CallStaticObjectMethod(jni_util_cl_, throwable_to_stack_trace_id_, exc));
         if (env->ExceptionOccurred()) {
             env->ExceptionClear();
             string oom_msg = absl::Substitute(oom_msg_template, "throwableToStackTrace");
             LOG(WARNING) << oom_msg;
             return Status::JniError(oom_msg);
         }

         auto* stask_str = env->GetStringUTFChars(stack, nullptr);
         LOG(WARNING) << stask_str;
         env->ReleaseStringUTFChars(stack, stask_str);
     }

     return Status::JniError("{}{}", prefix, return_msg);
 }

 bool Util::jvm_inited_ = false;

 jlong Util::max_jvm_heap_memory_size_ = 0;
 GlobalObject Util::jni_scanner_loader_obj_;
 MethodId Util::jni_scanner_loader_method_;
 MethodId Util::_clean_udf_cache_method_id;
 GlobalClass Util::hashmap_class;
 MethodId Util::hashmap_constructor;
 MethodId Util::hashmap_put;
 GlobalClass Util::mapClass;
 MethodId Util::mapEntrySetMethod;
 GlobalClass Util::mapEntryClass;
 MethodId Util::getEntryKeyMethod;
 MethodId Util::getEntryValueMethod;
 GlobalClass Util::setClass;
 MethodId Util::iteratorSetMethod;
 GlobalClass Util::iteratorClass;
 MethodId Util::iteratorHasNextMethod;
 MethodId Util::iteratorNextMethod;

 void Util::_parse_max_heap_memory_size_from_jvm() {
     // The start_be.sh would set JAVA_OPTS inside LIBHDFS_OPTS
     std::string java_opts = getenv("LIBHDFS_OPTS") ? getenv("LIBHDFS_OPTS") : "";
     std::istringstream iss(java_opts);
     std::string opt;
     while (iss >> opt) {
         if (opt.find("-Xmx") == 0) {
             std::string xmxValue = opt.substr(4);
             LOG(INFO) << "The max heap vaule is " << xmxValue;
             char unit = xmxValue.back();
             xmxValue.pop_back();
             long long value = std::stoll(xmxValue);
             switch (unit) {
             case 'g':
             case 'G':
                 max_jvm_heap_memory_size_ = value * 1024 * 1024 * 1024;
                 break;
             case 'm':
             case 'M':
                 max_jvm_heap_memory_size_ = value * 1024 * 1024;
                 break;
             case 'k':
             case 'K':
                 max_jvm_heap_memory_size_ = value * 1024;
                 break;
             default:
                 max_jvm_heap_memory_size_ = value;
                 break;
             }
         }
     }
     if (0 == max_jvm_heap_memory_size_) {
         LOG(FATAL) << "the max_jvm_heap_memory_size_ is " << max_jvm_heap_memory_size_;
     }
     LOG(INFO) << "the max_jvm_heap_memory_size_ is " << max_jvm_heap_memory_size_;
 }

 size_t Util::get_max_jni_heap_memory_size() {
 #if defined(USE_LIBHDFS3) || defined(BE_TEST)
     return std::numeric_limits<size_t>::max();
 #else
     static std::once_flag _parse_max_heap_memory_size_from_jvm_flag;
     std::call_once(_parse_max_heap_memory_size_from_jvm_flag, _parse_max_heap_memory_size_from_jvm);
     return max_jvm_heap_memory_size_;
 #endif
 }

 Status Util::_init_jni_scanner_loader() {
     JNIEnv* env = nullptr;
     RETURN_IF_ERROR(Jni::Env::Get(&env));
     LocalClass jni_scanner_loader_cls;
     std::string jni_scanner_loader_str = "org/apache/doris/common/classloader/ScannerLoader";
     RETURN_IF_ERROR(find_class(env, jni_scanner_loader_str.c_str(), &jni_scanner_loader_cls));

     MethodId jni_scanner_loader_constructor;
     RETURN_IF_ERROR(jni_scanner_loader_cls.get_method(env, "<init>", "()V",
                                                       &jni_scanner_loader_constructor));

     RETURN_IF_ERROR(jni_scanner_loader_cls.get_method(env, "getLoadedClass",
                                                       "(Ljava/lang/String;)Ljava/lang/Class;",
                                                       &jni_scanner_loader_method_));

     MethodId load_jni_scanner;
     RETURN_IF_ERROR(
             jni_scanner_loader_cls.get_method(env, "loadAllScannerJars", "()V", &load_jni_scanner));

     RETURN_IF_ERROR(jni_scanner_loader_cls.get_method(
             env, "cleanUdfClassLoader", "(Ljava/lang/String;)V", &_clean_udf_cache_method_id));

     RETURN_IF_ERROR(jni_scanner_loader_cls.new_object(env, jni_scanner_loader_constructor)
                             .call(&jni_scanner_loader_obj_));

     RETURN_IF_ERROR(jni_scanner_loader_obj_.call_void_method(env, load_jni_scanner).call());
     return Status::OK();
 }

 Status Util::clean_udf_class_load_cache(const std::string& function_signature) {
     JNIEnv* env = nullptr;
     RETURN_IF_ERROR(Jni::Env::Get(&env));

     LocalString function_signature_jstr;
     RETURN_IF_ERROR(
             LocalString::new_string(env, function_signature.c_str(), &function_signature_jstr));

     RETURN_IF_ERROR(jni_scanner_loader_obj_.call_void_method(env, _clean_udf_cache_method_id)
                             .with_arg(function_signature_jstr)
                             .call());

     return Status::OK();
 }

 Status Util::_init_collect_class() {
     JNIEnv* env = nullptr;
     RETURN_IF_ERROR(Jni::Env::Get(&env));
     // for hashmap
     RETURN_IF_ERROR(find_class(env, "java/util/HashMap", &hashmap_class));
     RETURN_IF_ERROR(hashmap_class.get_method(env, "<init>", "(I)V", &hashmap_constructor));
     RETURN_IF_ERROR(hashmap_class.get_method(
             env, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", &hashmap_put));

     //for map
     RETURN_IF_ERROR(find_class(env, "java/util/Map", &mapClass));
     RETURN_IF_ERROR(mapClass.get_method(env, "entrySet", "()Ljava/util/Set;", &mapEntrySetMethod));

     //for set
     RETURN_IF_ERROR(find_class(env, "java/util/Set", &setClass));
     RETURN_IF_ERROR(
             setClass.get_method(env, "iterator", "()Ljava/util/Iterator;", &iteratorSetMethod));

     // for iterator
     RETURN_IF_ERROR(find_class(env, "java/util/Iterator", &iteratorClass));
     RETURN_IF_ERROR(iteratorClass.get_method(env, "hasNext", "()Z", &iteratorHasNextMethod));
     RETURN_IF_ERROR(
             iteratorClass.get_method(env, "next", "()Ljava/lang/Object;", &iteratorNextMethod));

     //for map entry
     RETURN_IF_ERROR(find_class(env, "java/util/Map$Entry", &mapEntryClass));
     RETURN_IF_ERROR(
             mapEntryClass.get_method(env, "getKey", "()Ljava/lang/Object;", &getEntryKeyMethod));

     RETURN_IF_ERROR(mapEntryClass.get_method(env, "getValue", "()Ljava/lang/Object;",
                                              &getEntryValueMethod));

     return Status::OK();
 }

 Status Util::Init() {
     RETURN_IF_ERROR(Env::Init());
     RETURN_IF_ERROR(_init_register_natives());
     RETURN_IF_ERROR(_init_collect_class());
     RETURN_IF_ERROR(_init_jni_scanner_loader());
     jvm_inited_ = true;
     DorisMetrics::instance()->init_jvm_metrics();
     return Status::OK();
 }

 Status Util::_init_register_natives() {
     JNIEnv* env = nullptr;
     RETURN_IF_ERROR(Jni::Env::Get(&env));
     // Find JNINativeMethod class and create a global ref.
     jclass local_jni_native_exc_cl =
             env->FindClass("org/apache/doris/common/jni/utils/JNINativeMethod");
     if (local_jni_native_exc_cl == nullptr) {
         if (env->ExceptionOccurred()) {
             env->ExceptionDescribe();
         }
         return Status::JniError("Failed to find JNINativeMethod class.");
     }

     static char memory_alloc_name[] = "memoryTrackerMalloc";
     static char memory_alloc_sign[] = "(J)J";
     static char memory_free_name[] = "memoryTrackerFree";
     static char memory_free_sign[] = "(J)V";
     static char memory_alloc_batch_name[] = "memoryTrackerMallocBatch";
     static char memory_alloc_batch_sign[] = "([I)[J";
     static char memory_free_batch_name[] = "memoryTrackerFreeBatch";
     static char memory_free_batch_sign[] = "([J)V";
     static JNINativeMethod java_native_methods[] = {
             {memory_alloc_name, memory_alloc_sign, (void*)&JavaNativeMethods::memoryMalloc},
             {memory_free_name, memory_free_sign, (void*)&JavaNativeMethods::memoryFree},
             {memory_alloc_batch_name, memory_alloc_batch_sign,
              (void*)&JavaNativeMethods::memoryMallocBatch},
             {memory_free_batch_name, memory_free_batch_sign,
              (void*)&JavaNativeMethods::memoryFreeBatch},
     };

     int res = env->RegisterNatives(local_jni_native_exc_cl, java_native_methods,
                                    sizeof(java_native_methods) / sizeof(java_native_methods[0]));
     DCHECK_EQ(res, 0);
     if (res) [[unlikely]] {
         return Status::JniError("Failed to RegisterNatives.");
     }
     return Status::OK();
 }

 } // namespace Jni
 #include "common/compile_check_end.h"
 } // namespace doris
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.

	#include "util/jni-util.h"

	#include <fmt/format.h>
	#include <glog/logging.h>
	#include <jni.h>
	#include <jni_md.h>

	#include <cstdlib>
	#include <filesystem>
	#include <iterator>
	#include <memory>
	#include <mutex>
	#include <sstream>
	#include <string>
	#include <vector>

	#include "absl/strings/substitute.h"
	#include "common/cast_set.h"
	#include "common/config.h"
	#include "util/doris_metrics.h"
	#include "util/jni_native_method.h"
	// #include "util/libjvm_loader.h"

	using std::string;

	namespace doris {
	#include "common/compile_check_begin.h"
	namespace Jni {
	JavaVM* g_vm;
	[[maybe_unused]] std::once_flag g_vm_once;
	[[maybe_unused]] std::once_flag g_jvm_conf_once;
	__thread JNIEnv* Env::tls_env_ = nullptr;
	jclass Env::jni_util_cl_ = nullptr;
	jmethodID Env::throwable_to_string_id_ = nullptr;
	jmethodID Env::throwable_to_stack_trace_id_ = nullptr;

	const std::string GetDorisJNIDefaultClasspath() {
	const auto* doris_home = getenv("DORIS_HOME");
	DCHECK(doris_home) << "Environment variable DORIS_HOME is not set.";

	std::ostringstream out;

	auto add_jars_from_path = [&](const std::string& base_path) {
	if (!std::filesystem::exists(base_path)) {
	return;
	}
	for (const auto& entry : std::filesystem::recursive_directory_iterator(base_path)) {
	if (entry.path().extension() == ".jar") {
	if (!out.str().empty()) {
	out << ":";
	}
	out << entry.path().string();
	}
	}
	};

	add_jars_from_path(std::string(doris_home) + "/lib");
	add_jars_from_path(std::string(doris_home) + "/custom_lib");

	// Check and add HADOOP_CONF_DIR if it's set
	const auto* hadoop_conf_dir = getenv("HADOOP_CONF_DIR");
	if (hadoop_conf_dir != nullptr && strlen(hadoop_conf_dir) > 0) {
	if (!out.str().empty()) {
	out << ":";
	}
	out << hadoop_conf_dir;
	}

	DCHECK(!out.str().empty()) << "Empty classpath is invalid.";
	return out.str();
	}

	const std::string GetDorisJNIClasspathOption() {
	const auto* classpath = getenv("DORIS_CLASSPATH");
	if (classpath) {
	return classpath;
	} else {
	return "-Djava.class.path=" + GetDorisJNIDefaultClasspath();
	}
	}

	const std::string GetKerb5ConfPath() {
	return "-Djava.security.krb5.conf=" + config::kerberos_krb5_conf_path;
	}

	[[maybe_unused]] void SetEnvIfNecessary() {
	std::string libhdfs_opts = getenv("LIBHDFS_OPTS") ? getenv("LIBHDFS_OPTS") : "";
	CHECK(libhdfs_opts != "") << "LIBHDFS_OPTS is not set";
	libhdfs_opts += fmt::format(" {} ", GetKerb5ConfPath());
	libhdfs_opts += fmt::format(" -Djdk.lang.processReaperUseDefaultStackSize={}",
	config::jdk_process_reaper_use_default_stack_size);
	setenv("LIBHDFS_OPTS", libhdfs_opts.c_str(), 1);
	LOG(INFO) << "set final LIBHDFS_OPTS: " << libhdfs_opts;
	}

	// Only used on non-x86 platform
	[[maybe_unused]] void FindOrCreateJavaVM() {
	int num_vms;
	int rv = JNI_GetCreatedJavaVMs(&g_vm, 1, &num_vms);
	if (rv == 0) {
	std::vector<std::string> options;

	char* java_opts = getenv("JAVA_OPTS");
	if (java_opts == nullptr) {
	options = {
	GetDorisJNIClasspathOption(), fmt::format("-Xmx{}", "1g"),
	fmt::format("-DlogPath={}/log/jni.log", getenv("DORIS_HOME")),
	fmt::format("-Dsun.java.command={}", "DorisBE"), "-XX:-CriticalJNINatives",
	fmt::format("-Djdk.lang.processReaperUseDefaultStackSize={}",
	config::jdk_process_reaper_use_default_stack_size),
	#ifdef __APPLE__
	// On macOS, we should disable MaxFDLimit, otherwise the RLIMIT_NOFILE
	// will be assigned the minimum of OPEN_MAX (10240) and rlim_cur (See src/hotspot/os/bsd/os_bsd.cpp)
	// and it can not pass the check performed by storage engine.
	// The newer JDK has fixed this issue.
	"-XX:-MaxFDLimit"
	#endif
	};
	} else {
	std::istringstream stream(java_opts);
	options = std::vector<std::string>(std::istream_iterator<std::string> {stream},
	std::istream_iterator<std::string>());
	options.push_back(GetDorisJNIClasspathOption());
	}
	options.push_back(GetKerb5ConfPath());
	std::unique_ptr<JavaVMOption[]> jvm_options(new JavaVMOption[options.size()]);
	for (int i = 0; i < options.size(); ++i) {
	// To convert a string to a char*, const_cast is used.
	jvm_options[i] = {const_cast<char*>(options[i].c_str()), nullptr};
	}

	JNIEnv* env = nullptr;
	JavaVMInitArgs vm_args;
	vm_args.version = JNI_VERSION_1_8;
	vm_args.options = jvm_options.get();
	vm_args.nOptions = cast_set<int>(options.size());
	// Set it to JNI_FALSE because JNI_TRUE will let JVM ignore the max size config.
	vm_args.ignoreUnrecognized = JNI_FALSE;

	jint res = JNI_CreateJavaVM(&g_vm, (void**)&env, &vm_args);
	if (JNI_OK != res) {
	DCHECK(false) << "Failed to create JVM, code= " << res;
	}

	} else {
	CHECK_EQ(rv, 0) << "Could not find any created Java VM";
	CHECK_EQ(num_vms, 1) << "No VMs returned";
	}
	}

	Status Env::GetJNIEnvSlowPath(JNIEnv** env) {
	DCHECK(!tls_env_) << "Call GetJNIEnv() fast path";

	#ifdef USE_LIBHDFS3
	std::call_once(g_vm_once, FindOrCreateJavaVM);
	int rc = g_vm->GetEnv(reinterpret_cast<void**>(&tls_env_), JNI_VERSION_1_8);
	if (rc == JNI_EDETACHED) {
	rc = g_vm->AttachCurrentThread((void**)&tls_env_, nullptr);
	}
	if (rc != 0 \|\| tls_env_ == nullptr) {
	return Status::JniError("Unable to get JVM: {}", rc);
	}
	#else
	// the hadoop libhdfs will do all the stuff
	std::call_once(g_jvm_conf_once, SetEnvIfNecessary);
	tls_env_ = getJNIEnv();
	#endif
	*env = tls_env_;
	return Status::OK();
	}

	Status Env::GetJniExceptionMsg(JNIEnv* env, bool log_stack, const string& prefix) {
	jthrowable exc = env->ExceptionOccurred();
	Defer def {[&]() { env->DeleteLocalRef(exc); }};
	if (exc == nullptr) {
	return Status::OK();
	}
	env->ExceptionClear();
	DCHECK(throwable_to_string_id_ != nullptr);
	const char* oom_msg_template =
	"$0 threw an unchecked exception. The JVM is likely out "
	"of memory (OOM).";
	jstring msg = static_cast<jstring>(
	env->CallStaticObjectMethod(jni_util_cl_, throwable_to_string_id_, exc));
	if (env->ExceptionOccurred()) {
	env->ExceptionClear();
	string oom_msg = absl::Substitute(oom_msg_template, "throwableToString");
	LOG(WARNING) << oom_msg;
	return Status::JniError(oom_msg);
	}

	std::string return_msg;
	auto* msg_str = env->GetStringUTFChars(msg, nullptr);
	return_msg += msg_str;
	env->ReleaseStringUTFChars((jstring)msg, msg_str);

	if (log_stack) {
	jstring stack = static_cast<jstring>(
	env->CallStaticObjectMethod(jni_util_cl_, throwable_to_stack_trace_id_, exc));
	if (env->ExceptionOccurred()) {
	env->ExceptionClear();
	string oom_msg = absl::Substitute(oom_msg_template, "throwableToStackTrace");
	LOG(WARNING) << oom_msg;
	return Status::JniError(oom_msg);
	}

	auto* stask_str = env->GetStringUTFChars(stack, nullptr);
	LOG(WARNING) << stask_str;
	env->ReleaseStringUTFChars(stack, stask_str);
	}

	return Status::JniError("{}{}", prefix, return_msg);
	}

	bool Util::jvm_inited_ = false;

	jlong Util::max_jvm_heap_memory_size_ = 0;
	GlobalObject Util::jni_scanner_loader_obj_;
	MethodId Util::jni_scanner_loader_method_;
	MethodId Util::_clean_udf_cache_method_id;
	GlobalClass Util::hashmap_class;
	MethodId Util::hashmap_constructor;
	MethodId Util::hashmap_put;
	GlobalClass Util::mapClass;
	MethodId Util::mapEntrySetMethod;
	GlobalClass Util::mapEntryClass;
	MethodId Util::getEntryKeyMethod;
	MethodId Util::getEntryValueMethod;
	GlobalClass Util::setClass;
	MethodId Util::iteratorSetMethod;
	GlobalClass Util::iteratorClass;
	MethodId Util::iteratorHasNextMethod;
	MethodId Util::iteratorNextMethod;

	void Util::_parse_max_heap_memory_size_from_jvm() {
	// The start_be.sh would set JAVA_OPTS inside LIBHDFS_OPTS
	std::string java_opts = getenv("LIBHDFS_OPTS") ? getenv("LIBHDFS_OPTS") : "";
	std::istringstream iss(java_opts);
	std::string opt;
	while (iss >> opt) {
	if (opt.find("-Xmx") == 0) {
	std::string xmxValue = opt.substr(4);
	LOG(INFO) << "The max heap vaule is " << xmxValue;
	char unit = xmxValue.back();
	xmxValue.pop_back();
	long long value = std::stoll(xmxValue);
	switch (unit) {
	case 'g':
	case 'G':
	max_jvm_heap_memory_size_ = value * 1024 * 1024 * 1024;
	break;
	case 'm':
	case 'M':
	max_jvm_heap_memory_size_ = value * 1024 * 1024;
	break;
	case 'k':
	case 'K':
	max_jvm_heap_memory_size_ = value * 1024;
	break;
	default:
	max_jvm_heap_memory_size_ = value;
	break;
	}
	}
	}
	if (0 == max_jvm_heap_memory_size_) {
	LOG(FATAL) << "the max_jvm_heap_memory_size_ is " << max_jvm_heap_memory_size_;
	}
	LOG(INFO) << "the max_jvm_heap_memory_size_ is " << max_jvm_heap_memory_size_;
	}

	size_t Util::get_max_jni_heap_memory_size() {
	#if defined(USE_LIBHDFS3) \|\| defined(BE_TEST)
	return std::numeric_limits<size_t>::max();
	#else
	static std::once_flag _parse_max_heap_memory_size_from_jvm_flag;
	std::call_once(_parse_max_heap_memory_size_from_jvm_flag, _parse_max_heap_memory_size_from_jvm);
	return max_jvm_heap_memory_size_;
	#endif
	}

	Status Util::_init_jni_scanner_loader() {
	JNIEnv* env = nullptr;
	RETURN_IF_ERROR(Jni::Env::Get(&env));
	LocalClass jni_scanner_loader_cls;
	std::string jni_scanner_loader_str = "org/apache/doris/common/classloader/ScannerLoader";
	RETURN_IF_ERROR(find_class(env, jni_scanner_loader_str.c_str(), &jni_scanner_loader_cls));

	MethodId jni_scanner_loader_constructor;
	RETURN_IF_ERROR(jni_scanner_loader_cls.get_method(env, "<init>", "()V",
	&jni_scanner_loader_constructor));

	RETURN_IF_ERROR(jni_scanner_loader_cls.get_method(env, "getLoadedClass",
	"(Ljava/lang/String;)Ljava/lang/Class;",
	&jni_scanner_loader_method_));

	MethodId load_jni_scanner;
	RETURN_IF_ERROR(
	jni_scanner_loader_cls.get_method(env, "loadAllScannerJars", "()V", &load_jni_scanner));

	RETURN_IF_ERROR(jni_scanner_loader_cls.get_method(
	env, "cleanUdfClassLoader", "(Ljava/lang/String;)V", &_clean_udf_cache_method_id));

	RETURN_IF_ERROR(jni_scanner_loader_cls.new_object(env, jni_scanner_loader_constructor)
	.call(&jni_scanner_loader_obj_));

	RETURN_IF_ERROR(jni_scanner_loader_obj_.call_void_method(env, load_jni_scanner).call());
	return Status::OK();
	}

	Status Util::clean_udf_class_load_cache(const std::string& function_signature) {
	JNIEnv* env = nullptr;
	RETURN_IF_ERROR(Jni::Env::Get(&env));

	LocalString function_signature_jstr;
	RETURN_IF_ERROR(
	LocalString::new_string(env, function_signature.c_str(), &function_signature_jstr));

	RETURN_IF_ERROR(jni_scanner_loader_obj_.call_void_method(env, _clean_udf_cache_method_id)
	.with_arg(function_signature_jstr)
	.call());

	return Status::OK();
	}

	Status Util::_init_collect_class() {
	JNIEnv* env = nullptr;
	RETURN_IF_ERROR(Jni::Env::Get(&env));
	// for hashmap
	RETURN_IF_ERROR(find_class(env, "java/util/HashMap", &hashmap_class));
	RETURN_IF_ERROR(hashmap_class.get_method(env, "<init>", "(I)V", &hashmap_constructor));
	RETURN_IF_ERROR(hashmap_class.get_method(
	env, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", &hashmap_put));

	//for map
	RETURN_IF_ERROR(find_class(env, "java/util/Map", &mapClass));
	RETURN_IF_ERROR(mapClass.get_method(env, "entrySet", "()Ljava/util/Set;", &mapEntrySetMethod));

	//for set
	RETURN_IF_ERROR(find_class(env, "java/util/Set", &setClass));
	RETURN_IF_ERROR(
	setClass.get_method(env, "iterator", "()Ljava/util/Iterator;", &iteratorSetMethod));

	// for iterator
	RETURN_IF_ERROR(find_class(env, "java/util/Iterator", &iteratorClass));
	RETURN_IF_ERROR(iteratorClass.get_method(env, "hasNext", "()Z", &iteratorHasNextMethod));
	RETURN_IF_ERROR(
	iteratorClass.get_method(env, "next", "()Ljava/lang/Object;", &iteratorNextMethod));

	//for map entry
	RETURN_IF_ERROR(find_class(env, "java/util/Map$Entry", &mapEntryClass));
	RETURN_IF_ERROR(
	mapEntryClass.get_method(env, "getKey", "()Ljava/lang/Object;", &getEntryKeyMethod));

	RETURN_IF_ERROR(mapEntryClass.get_method(env, "getValue", "()Ljava/lang/Object;",
	&getEntryValueMethod));

	return Status::OK();
	}

	Status Util::Init() {
	RETURN_IF_ERROR(Env::Init());
	RETURN_IF_ERROR(_init_register_natives());
	RETURN_IF_ERROR(_init_collect_class());
	RETURN_IF_ERROR(_init_jni_scanner_loader());
	jvm_inited_ = true;
	DorisMetrics::instance()->init_jvm_metrics();
	return Status::OK();
	}

	Status Util::_init_register_natives() {
	JNIEnv* env = nullptr;
	RETURN_IF_ERROR(Jni::Env::Get(&env));
	// Find JNINativeMethod class and create a global ref.
	jclass local_jni_native_exc_cl =
	env->FindClass("org/apache/doris/common/jni/utils/JNINativeMethod");
	if (local_jni_native_exc_cl == nullptr) {
	if (env->ExceptionOccurred()) {
	env->ExceptionDescribe();
	}
	return Status::JniError("Failed to find JNINativeMethod class.");
	}

	static char memory_alloc_name[] = "memoryTrackerMalloc";
	static char memory_alloc_sign[] = "(J)J";
	static char memory_free_name[] = "memoryTrackerFree";
	static char memory_free_sign[] = "(J)V";
	static char memory_alloc_batch_name[] = "memoryTrackerMallocBatch";
	static char memory_alloc_batch_sign[] = "([I)[J";
	static char memory_free_batch_name[] = "memoryTrackerFreeBatch";
	static char memory_free_batch_sign[] = "([J)V";
	static JNINativeMethod java_native_methods[] = {
	{memory_alloc_name, memory_alloc_sign, (void*)&JavaNativeMethods::memoryMalloc},
	{memory_free_name, memory_free_sign, (void*)&JavaNativeMethods::memoryFree},
	{memory_alloc_batch_name, memory_alloc_batch_sign,
	(void*)&JavaNativeMethods::memoryMallocBatch},
	{memory_free_batch_name, memory_free_batch_sign,
	(void*)&JavaNativeMethods::memoryFreeBatch},
	};

	int res = env->RegisterNatives(local_jni_native_exc_cl, java_native_methods,
	sizeof(java_native_methods) / sizeof(java_native_methods[0]));
	DCHECK_EQ(res, 0);
	if (res) [[unlikely]] {
	return Status::JniError("Failed to RegisterNatives.");
	}
	return Status::OK();
	}

	} // namespace Jni
	#include "common/compile_check_end.h"
	} // namespace doris