| /* |
| * Copyright (c) 2010 ARM Limited |
| * All rights reserved |
| * |
| * The license below extends only to copyright in the software and shall |
| * not be construed as granting a license to any other intellectual |
| * property including but not limited to intellectual property relating |
| * to a hardware implementation of the functionality of the software |
| * licensed hereunder. You may use the software subject to the license |
| * terms below provided that you ensure that this notice is replicated |
| * unmodified and in its entirety in all distributions of the software, |
| * modified or unmodified, in source code or in binary form. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer; |
| * redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution; |
| * neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <stdint.h> |
| #include <iostream> |
| #include <string> |
| |
| #include "call_type/addr_dt.hh" |
| #include "call_type/inst_dt.hh" |
| #include "call_type/semi_dt.hh" |
| #include "gem5/m5ops.h" |
| #include "java/gem5_Ops.h" |
| #include "m5_mmap.h" |
| |
| #define _stringify(x) #x |
| #define stringify(x) _stringify(x) |
| |
| struct JavaCallType |
| { |
| const std::string name; |
| DispatchTable *dt; |
| }; |
| |
| JavaCallType java_call_types[] = { |
| #if CALL_TYPE_addr_ENABLED |
| { "addr", &addr_dispatch }, |
| #endif |
| #if CALL_TYPE_inst_ENABLED |
| { "inst", &inst_dispatch }, |
| #endif |
| #if CALL_TYPE_semi_ENABLED |
| { "semi", &semi_dispatch }, |
| #endif |
| }; |
| |
| /* |
| * C library interface for gem5Op JNI |
| */ |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_setupCallTypes(JNIEnv *env, jclass clazz) |
| { |
| jclass map_class = env->FindClass("java/util/HashMap"); |
| jmethodID map_constr_id = env->GetMethodID(map_class, "<init>", "()V"); |
| jobject map = env->NewObject(map_class, map_constr_id); |
| |
| jfieldID map_field_id = env->GetStaticFieldID( |
| clazz, "_callTypes", "Ljava/util/Map;"); |
| env->SetStaticObjectField(clazz, map_field_id, map); |
| |
| jmethodID map_put_id = env->GetMethodID(map_class, "put", |
| "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); |
| |
| jmethodID ops_constr_id = env->GetMethodID(clazz, "<init>", "()V"); |
| jfieldID ptr_field_id = env->GetFieldID(clazz, "dispatchTablePtr", "J"); |
| |
| for (const auto &ct: java_call_types) { |
| jobject ops = env->NewObject(clazz, ops_constr_id); |
| env->SetLongField(ops, ptr_field_id, (int64_t)(intptr_t)ct.dt); |
| |
| jstring name = env->NewStringUTF(ct.name.c_str()); |
| |
| env->CallObjectMethod(map, map_put_id, name, ops); |
| |
| if (ct.name == stringify(CALL_TYPE_DEFAULT)) { |
| jstring default_name = env->NewStringUTF("default"); |
| env->CallObjectMethod(map, map_put_id, default_name, ops); |
| env->DeleteLocalRef(default_name); |
| } |
| |
| env->DeleteLocalRef(name); |
| env->DeleteLocalRef(ops); |
| } |
| |
| env->DeleteLocalRef(map); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_setAddr(JNIEnv *env, jclass clazz, jlong addr) |
| { |
| m5op_addr = addr; |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_mapMem(JNIEnv *env, jclass clazz) |
| { |
| map_m5_mem(); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_unmapMem(JNIEnv *env, jclass clazz) |
| { |
| unmap_m5_mem(); |
| } |
| |
| static DispatchTable * |
| getDispatchTable(JNIEnv *env, jobject obj) |
| { |
| jclass clazz = env->GetObjectClass(obj); |
| jfieldID ptr_field_id = env->GetFieldID(clazz, "dispatchTablePtr", "J"); |
| return (DispatchTable *)(intptr_t)(env->GetLongField(obj, ptr_field_id)); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_arm(JNIEnv *env, jobject obj, jlong j_address) |
| { |
| getDispatchTable(env, obj)->m5_arm(j_address); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_quiesce(JNIEnv *env, jobject obj) |
| { |
| getDispatchTable(env, obj)->m5_quiesce(); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_quiesce_1ns(JNIEnv *env, jobject obj, jlong j_ns) |
| { |
| getDispatchTable(env, obj)->m5_quiesce_ns(j_ns); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_quiesce_1cycle(JNIEnv *env, jobject obj, jlong j_cycles) |
| { |
| getDispatchTable(env, obj)->m5_quiesce_cycle(j_cycles); |
| } |
| |
| JNIEXPORT jlong JNICALL |
| Java_gem5_Ops_quiesce_1time(JNIEnv *env, jobject obj) |
| { |
| uint64_t time = getDispatchTable(env, obj)->m5_quiesce_time(); |
| if (time & 0x8000000000000000ULL) |
| printf("Truncated return value from quiesceTime() to 63 bits\n"); |
| return (time & 0x7FFFFFFFFFFFFFFFULL); |
| } |
| |
| JNIEXPORT jlong JNICALL |
| Java_gem5_Ops_rpns(JNIEnv *env, jobject obj) |
| { |
| uint64_t time = getDispatchTable(env, obj)->m5_rpns(); |
| if (time & 0x8000000000000000ULL) |
| printf("Truncated return value from rpns() to 63 bits\n"); |
| return (time & 0x7FFFFFFFFFFFFFFFULL); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_wake_1cpu(JNIEnv *env, jobject obj, jlong j_cpuid) |
| { |
| getDispatchTable(env, obj)->m5_wake_cpu(j_cpuid); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_exit(JNIEnv *env, jobject obj, jlong j_ns_delay) |
| { |
| getDispatchTable(env, obj)->m5_exit(j_ns_delay); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_fail(JNIEnv *env, jobject obj, jlong j_ns_delay, jlong j_code) |
| { |
| getDispatchTable(env, obj)->m5_fail(j_ns_delay, j_code); |
| } |
| |
| JNIEXPORT jlong JNICALL |
| Java_gem5_Ops_sum(JNIEnv *env, jobject obj, jlong a, jlong b, jlong c, |
| jlong d, jlong e, jlong f) |
| { |
| uint64_t result = getDispatchTable(env, obj)->m5_sum(a, b, c, d, e, f); |
| if (result & 0x8000000000000000ULL) |
| printf("Truncated return value from sum() to 63 bits\n"); |
| return (result & 0x7FFFFFFFFFFFFFFFULL); |
| } |
| |
| JNIEXPORT jlong JNICALL |
| Java_gem5_Ops_init_1param(JNIEnv *env, jobject obj, jlong j_key_str1, |
| jlong j_key_str2) |
| { |
| uint64_t param = getDispatchTable(env, obj)->m5_init_param( |
| j_key_str1, j_key_str2); |
| if (param & 0x8000000000000000ULL) |
| printf("Truncated return value from m_initparam() to 63 bits\n"); |
| return (param & 0x7FFFFFFFFFFFFFFFULL); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_checkpoint(JNIEnv *env, jobject obj, |
| jlong j_ns_delay, jlong j_ns_period) |
| { |
| getDispatchTable(env, obj)->m5_checkpoint(j_ns_delay, j_ns_period); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_reset_1stats(JNIEnv *env, jobject obj, |
| jlong j_ns_delay, jlong j_ns_period) |
| { |
| getDispatchTable(env, obj)->m5_reset_stats(j_ns_delay, j_ns_period); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_dump_1stats(JNIEnv *env, jobject obj, |
| jlong j_ns_delay, jlong j_ns_period) |
| { |
| getDispatchTable(env, obj)->m5_dump_stats(j_ns_delay, j_ns_period); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_dump_1reset_1stats(JNIEnv *env, jobject obj, |
| jlong j_ns_delay, jlong j_ns_period) |
| { |
| getDispatchTable(env, obj)->m5_dump_reset_stats(j_ns_delay, j_ns_period); |
| } |
| |
| JNIEXPORT jlong JNICALL |
| Java_gem5_Ops_read_1file(JNIEnv *env, jobject obj, |
| jbyteArray j_buffer, jlong j_len, jlong j_offset) |
| { |
| jbyte *buffer = env->GetByteArrayElements(j_buffer, 0); |
| |
| uint64_t result = getDispatchTable(env, obj)->m5_read_file( |
| buffer, j_len, j_offset); |
| |
| env->ReleaseByteArrayElements(j_buffer, buffer, JNI_ABORT); |
| return (result & 0x7FFFFFFFFFFFFFFFULL); |
| } |
| |
| JNIEXPORT jlong JNICALL |
| Java_gem5_Ops_write_1file(JNIEnv *env, jobject obj, |
| jbyteArray j_buffer, jlong j_len, jlong j_offset, |
| jstring j_filename) |
| { |
| jbyte *buffer = env->GetByteArrayElements(j_buffer, 0); |
| const char *filename = env->GetStringUTFChars(j_filename, NULL); |
| |
| uint64_t result = getDispatchTable(env, obj)->m5_write_file( |
| buffer, j_len, j_offset, filename); |
| |
| env->ReleaseStringUTFChars(j_filename, filename); |
| env->ReleaseByteArrayElements(j_buffer, buffer, JNI_ABORT); |
| return (result & 0x7FFFFFFFFFFFFFFFULL); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_debug_1break(JNIEnv *env, jobject obj) |
| { |
| getDispatchTable(env, obj)->m5_debug_break(); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_switch_1cpu (JNIEnv *env, jobject obj) |
| { |
| getDispatchTable(env, obj)->m5_switch_cpu(); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_dist_1toggle_1sync(JNIEnv *env, jobject obj) |
| { |
| getDispatchTable(env, obj)->m5_dist_toggle_sync(); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_add_symbol(JNIEnv *env, jobject obj, |
| jlong j_addr, jstring j_symbol) |
| { |
| const char *symbol = env->GetStringUTFChars(j_symbol, NULL); |
| |
| getDispatchTable(env, obj)->m5_add_symbol(j_addr, symbol); |
| |
| env->ReleaseStringUTFChars(j_symbol, symbol); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_load_1symbol(JNIEnv *env, jobject obj) |
| { |
| getDispatchTable(env, obj)->m5_load_symbol(); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_panic(JNIEnv *env, jobject obj) |
| { |
| getDispatchTable(env, obj)->m5_panic(); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_work_1begin(JNIEnv *env, jobject obj, |
| jlong j_workid, jlong j_threadid) |
| { |
| getDispatchTable(env, obj)->m5_work_begin(j_workid, j_threadid); |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gem5_Ops_work_1end(JNIEnv *env, jobject obj, |
| jlong j_workid, jlong j_threadid) |
| { |
| getDispatchTable(env, obj)->m5_work_end(j_workid, j_threadid); |
| } |
| |