/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed 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.
*/
/*
* dalvik.system.VMRuntime
*/
#include "Dalvik.h"
#include "native/InternalNativePriv.h"
#include <limits.h>
/*
* public native float getTargetHeapUtilization()
*
* Gets the current ideal heap utilization, represented as a number
* between zero and one.
*/
static void Dalvik_dalvik_system_VMRuntime_getTargetHeapUtilization(
const u4* args, JValue* pResult)
{
UNUSED_PARAMETER(args);
RETURN_FLOAT(dvmGetTargetHeapUtilization());
}
/*
* native float nativeSetTargetHeapUtilization()
*
* Sets the current ideal heap utilization, represented as a number
* between zero and one. Returns the old utilization.
*
* Note that this is NOT static.
*/
static void Dalvik_dalvik_system_VMRuntime_nativeSetTargetHeapUtilization(
const u4* args, JValue* pResult)
{
dvmSetTargetHeapUtilization(dvmU4ToFloat(args[1]));
RETURN_VOID();
}
/*
* native long nativeMinimumHeapSize(long size, boolean set)
*
* If set is true, sets the new minimum heap size to size; always
* returns the current (or previous) size. If size is negative or
* zero, removes the current minimum constraint (if present).
*/
static void Dalvik_dalvik_system_VMRuntime_nativeMinimumHeapSize(
const u4* args, JValue* pResult)
{
s8 longSize = GET_ARG_LONG(args, 1);
size_t size;
bool set = (args[3] != 0);
/* Fit in 32 bits. */
if (longSize < 0) {
size = 0;
} else if (longSize > INT_MAX) {
size = INT_MAX;
} else {
size = (size_t)longSize;
}
size = dvmMinimumHeapSize(size, set);
RETURN_LONG(size);
}
/*
* public native void gcSoftReferences()
*
* Does a GC and forces collection of SoftReferences that are
* not strongly-reachable.
*/
static void Dalvik_dalvik_system_VMRuntime_gcSoftReferences(const u4* args,
JValue* pResult)
{
dvmCollectGarbage(true);
RETURN_VOID();
}
/*
* public native void runFinalizationSync()
*
* Does not return until any pending finalizers have been called.
* This may or may not happen in the context of the calling thread.
* No exceptions will escape.
*
* Used by zygote, which doesn't have a HeapWorker thread.
*/
static void Dalvik_dalvik_system_VMRuntime_runFinalizationSync(const u4* args,
JValue* pResult)
{
dvmRunFinalizationSync();
RETURN_VOID();
}
/*
* public native boolean trackExternalAllocation(long size)
*
* Asks the VM if <size> bytes can be allocated in an external heap.
* This information may be used to limit the amount of memory available
* to Dalvik threads. Returns false if the VM would rather that the caller
* did not allocate that much memory. If the call returns false, the VM
* will not update its internal counts.
*/
static void Dalvik_dalvik_system_VMRuntime_trackExternalAllocation(
const u4* args, JValue* pResult)
{
s8 longSize = GET_ARG_LONG(args, 1);
/* Fit in 32 bits. */
if (longSize < 0) {
dvmThrowException("Ljava/lang/IllegalArgumentException;",
"size must be positive");
RETURN_VOID();
} else if (longSize > INT_MAX) {
dvmThrowException("Ljava/lang/UnsupportedOperationException;",
"size must fit in 32 bits");
RETURN_VOID();
}
RETURN_BOOLEAN(dvmTrackExternalAllocation((size_t)longSize));
}
/*
* public native void trackExternalFree(long size)
*
* Tells the VM that <size> bytes have been freed in an external
* heap. This information may be used to control the amount of memory
* available to Dalvik threads.
*/
static void Dalvik_dalvik_system_VMRuntime_trackExternalFree(
const u4* args, JValue* pResult)
{
s8 longSize = GET_ARG_LONG(args, 1);
/* Fit in 32 bits. */
if (longSize < 0) {
dvmThrowException("Ljava/lang/IllegalArgumentException;",
"size must be positive");
RETURN_VOID();
} else if (longSize > INT_MAX) {
dvmThrowException("Ljava/lang/UnsupportedOperationException;",
"size must fit in 32 bits");
RETURN_VOID();
}
dvmTrackExternalFree((size_t)longSize);
RETURN_VOID();
}
/*
* public native long getExternalBytesAllocated()
*
* Returns the number of externally-allocated bytes being tracked by
* trackExternalAllocation/Free().
*/
static void Dalvik_dalvik_system_VMRuntime_getExternalBytesAllocated(
const u4* args, JValue* pResult)
{
RETURN_LONG((s8)dvmGetExternalBytesAllocated());
}
/*
* public native void startJitCompilation()
*
* Callback function from the framework to indicate that an app has gone
* through the startup phase and it is time to enable the JIT compiler.
*/
static void Dalvik_dalvik_system_VMRuntime_startJitCompilation(const u4* args,
JValue* pResult)
{
#if defined(WITH_JIT)
if (gDvm.executionMode == kExecutionModeJit &&
gDvmJit.disableJit == false) {
dvmLockMutex(&gDvmJit.compilerLock);
gDvmJit.alreadyEnabledViaFramework = true;
pthread_cond_signal(&gDvmJit.compilerQueueActivity);
dvmUnlockMutex(&gDvmJit.compilerLock);
}
#endif
RETURN_VOID();
}
/*
* public native void disableJitCompilation()
*
* Callback function from the framework to indicate that a VM instance wants to
* permanently disable the JIT compiler. Currently only the system server uses
* this interface when it detects system-wide safe mode is enabled.
*/
static void Dalvik_dalvik_system_VMRuntime_disableJitCompilation(const u4* args,
JValue* pResult)
{
#if defined(WITH_JIT)
if (gDvm.executionMode == kExecutionModeJit) {
gDvmJit.disableJit = true;
}
#endif
RETURN_VOID();
}
const DalvikNativeMethod dvm_dalvik_system_VMRuntime[] = {
{ "getTargetHeapUtilization", "()F",
Dalvik_dalvik_system_VMRuntime_getTargetHeapUtilization },
{ "nativeSetTargetHeapUtilization", "(F)V",
Dalvik_dalvik_system_VMRuntime_nativeSetTargetHeapUtilization },
{ "nativeMinimumHeapSize", "(JZ)J",
Dalvik_dalvik_system_VMRuntime_nativeMinimumHeapSize },
{ "gcSoftReferences", "()V",
Dalvik_dalvik_system_VMRuntime_gcSoftReferences },
{ "runFinalizationSync", "()V",
Dalvik_dalvik_system_VMRuntime_runFinalizationSync },
{ "trackExternalAllocation", "(J)Z",
Dalvik_dalvik_system_VMRuntime_trackExternalAllocation },
{ "trackExternalFree", "(J)V",
Dalvik_dalvik_system_VMRuntime_trackExternalFree },
{ "getExternalBytesAllocated", "()J",
Dalvik_dalvik_system_VMRuntime_getExternalBytesAllocated },
{ "startJitCompilation", "()V",
Dalvik_dalvik_system_VMRuntime_startJitCompilation },
{ "disableJitCompilation", "()V",
Dalvik_dalvik_system_VMRuntime_disableJitCompilation },
{ NULL, NULL, NULL },
};