mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-15 22:03:26 +00:00
Code Issues Projects Releases Wiki Activity

Implement some library predicates for Java using JNI.

Browse Source 
Estimated hours taken: 13
Branches: main

Implement some library predicates for Java using JNI.

java/runtime/Native.java.in:
	A new class which uses JNI to provide any native functionality
	required by predicates of the standard library in Java.
	So far it only provides methods relating to timing.

java/runtime/Native.c:
	Source code, written in C, which implements all the native methods of
	mercury.runtime.Native.  Note that this implementation makes use of the
	existing C implementation of the equivalent functions.

java/runtime/Mmakefile:
	Rules for compiling a shared object from Native.c.

library/time.m:
	Implement the following predicates for Java using Native interface:
		time__c_clock/3
		time__clocks_per_sec/1
		time__times/7

library/benchmarking.m:
	Implement the following predicates for Java using Native interface:
		get_user_cpu_miliseconds/1

library/Mmakefile:
	Renamed to library/Mmakefile.in, so as to have access to FULLARCH
	constant.

library/Mmakefile.in:
	Added rules for incorporating the Native shared object.
This commit is contained in:
James Goddard
2004-02-05 03:56:05 +00:00
parent e138aeb225
commit 1e8afc7bee
6 changed files with 334 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
java/runtime/Mmakefile Normal file
View File

@@ -0,0 +1,35 @@
# Copyright (C) 2004 The University of Melbourne.
# This file may only be copied under the terms of the GNU Library General
# Public License - see the file COPYING.LIB in the Mercury distribution.
#
# This Makefile compiles the shared object for use with mercury.runtime.Native
#
MERCURY_DIR = ../..
RUNTIME_DIR = $(MERCURY_DIR)/runtime
include $(MERCURY_DIR)/Mmake.common
NATIVE_PIC = Native.$(EXT_FOR_PIC_OBJECTS)
NATIVE_SO = Native.$(EXT_FOR_SHARED_LIB)
MAIN_TARGET = $(NATIVE_SO)
PIC_OBJS = $(RUNTIME_DIR)/mercury_timing.$(EXT_FOR_PIC_OBJECTS) \
$(NATIVE_PIC)
CFLAGS = -I$(RUNTIME_DIR)
$(NATIVE_SO): $(PIC_OBJS)
$(LINK_SHARED_OBJ) -o $(NATIVE_SO) $(PIC_OBJS)
$(NATIVE_PIC): Native.c
$(MGNUC) $(ALL_GRADEFLAGS) $(ALL_MGNUCFLAGS) \
$(CFLAGS_FOR_PIC) -o $(NATIVE_PIC) -c Native.c
clean:
rm -f $(PIC_OBJS)
realclean:
rm -f $(PIC_OBJS) $(NATIVE_SO) *.class

99
java/runtime/Native.c Normal file
View File

@@ -0,0 +1,99 @@
/*
** Copyright (C) 2004 The University of Melbourne.
** This file may only be copied under the terms of the GNU Library General
** Public License - see the file COPYING.LIB in the Mercury distribution.
*/
/*
** File: Native.c - Native code for java/runtime/Native.java
*/
#include <jni.h>
/*
* Class: Native
* Method: clock
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_mercury_runtime_Native_clock(JNIEnv *, jclass);
/*
* Class: Native
* Method: clocks_per_sec
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_mercury_runtime_Native_clocks_1per_1sec(
JNIEnv *, jclass);
/*
* Class: Native
* Method: times
* Signature: ()[I
*/
JNIEXPORT jintArray JNICALL Java_mercury_runtime_Native_times(
JNIEnv *, jclass);
/*
* Class: Native
* Method: get_user_cpu_miliseconds
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_mercury_runtime_Native_get_1user_1cpu_1miliseconds(
JNIEnv *, jclass);
#include "mercury_imp.h"
#include "mercury_timing.h"
#include <time.h>
#ifdef MR_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef MR_HAVE_SYS_TIMES_H
#include <sys/times.h>
#endif
#ifdef MR_HAVE_UNISTD_H
#include <unistd.h>
#endif
JNIEXPORT jint JNICALL
Java_mercury_runtime_Native_clock(JNIEnv *env, jclass obj) {
return (MR_Integer) clock();
}
JNIEXPORT jint JNICALL
Java_mercury_runtime_Native_clocks_1per_1sec(JNIEnv *env, jclass obj) {
return CLOCKS_PER_SEC;
}
JNIEXPORT jintArray JNICALL
Java_mercury_runtime_Native_times(JNIEnv *env, jclass obj) {
jint intarray[5];
jintArray result;
#ifdef MR_HAVE_POSIX_TIMES
struct tms t;
intarray[0] = (MR_Integer) times(&t);
intarray[1] = (MR_Integer) t.tms_utime;
intarray[2] = (MR_Integer) t.tms_stime;
intarray[3] = (MR_Integer) t.tms_cutime;
intarray[4] = (MR_Integer) t.tms_cstime;
#else
intarray[0] = -1;
#endif
result = (*env)->NewIntArray(env, 5);
if (result != NULL) {
(*env)->SetIntArrayRegion(env, result, 0, 5, intarray);
}
return result;
}
JNIEXPORT jint JNICALL
Java_mercury_runtime_Native_get_1user_1cpu_1miliseconds(
JNIEnv *env, jclass obj)
{
return MR_get_user_cpu_miliseconds();
}

121
java/runtime/Native.java.in Normal file
View File

@@ -0,0 +1,121 @@
//
// Copyright (C) 2004 The University of Melbourne.
// This file may only be copied under the terms of the GNU Library General
// Public License - see the file COPYING.LIB in the Mercury distribution.
//
//
// This class exists to provide any native functionality required by the Java
// implementation. It uses JNI to access a shared object which it searches
// for in all the directories listed in the current CLASSPATH.
//
// At the moment the only services provided are those relating to timing.
//
package mercury.runtime;
public class Native {
/*
** SHARED_OBJ is the name of the shared object which contains all the
** compiled native code.
*/
private static final java.lang.String SHARED_OBJ =
"Native.@EXT_FOR_SHARED_LIB@";
/*
** available and isAvailable() are true when native functionality
** is available. (ie SHARED_OBJ was loaded successfully)
*/
private static boolean available = false;
public static boolean isAvailable() {
return available;
}
static {
available = load_library();
}
/*
** load_library():
** Searches all the directories listed in the classpath,
** (including the directories containing each jar file) for
** the shared object SHARED_OBJ and attempts to load this file
** if found.
** Also searches in the subdirectory Constants.MR_FULLARCH.
** Returns true if successful, false otherwise.
*/
private static boolean load_library() {
java.util.StringTokenizer classpath =
new java.util.StringTokenizer(
java.lang.System.getProperty("java.class.path")
,java.lang.System.getProperty("path.separator")
);
while (classpath.hasMoreTokens()) {
java.io.File dir;
java.io.File entry = new java.io.File(
classpath.nextToken());
try {
if (entry.isDirectory()) {
dir = entry;
} else {
dir = entry.getParentFile();
}
if (dir == null) {
dir = new java.io.File("");
}
java.io.File match = new java.io.File(dir,
SHARED_OBJ);
if (match.exists() == false) {
dir = new java.io.File(dir,
mercury.runtime.Constants.
MR_FULLARCH);
match = new java.io.File(dir,
SHARED_OBJ);
}
java.lang.System.load(match.getAbsolutePath());
return true;
}
catch (java.lang.Exception e) {
continue;
}
} // while classpath.hasMoreTokens()
return false;
} // load_library()
/*
** clock():
** Calls clock() from the <time.h> library.
*/
public static native int clock();
/*
** clocks_per_sec():
** Returns the number of "clocks" per sec as defined by
** CLOCKS_PER_SEC.
*/
public static native int clocks_per_sec();
/*
** times():
** Calls times() from the <time.h> library. Results are returned
** in an int array of the form:
** { <return value>, utime, stime, cutime, cstime }
** If POSIX times are not available, <return value> will be set
** to -1, and the other values are undefined.
** Returns null if the array cannot be constructed.
*/
public static native int[] times();
/*
** get_user_cpu_miliseconds():
** Native method to return the CPU time consumed by the process,
** in miliseconds, from an arbitrary initial time.
*/
public static native int get_user_cpu_miliseconds();
}

18
library/Mmakefile → library/Mmakefile.in
View File

@@ -24,6 +24,7 @@ ALLOW_LIB_PREFIX=yes
ALLOW_BROWSER_PREFIX=no
MERCURY_DIR=..
FULLARCH=@FULLARCH@
LINK_RUNTIME_ONLY=yes
include $(MERCURY_DIR)/Mmake.common
-include Mmake.library.params
@@ -244,12 +245,23 @@ java_symlinks:
# jar file. At this point we also add the runtime classes to a jar file.
# Note that this stage makes use of the symbolic links created earlier to
# ensure that the path names are correct within the jar files.
# We also compile NATIVE_SO here and copy it into the library directory.
JARS = $(STD_LIB_NAME).jar $(STD_LIB_NAME).runtime.jar
# We ignore the exit status of the last two commands because NATIVE_SO is not
# an essential part of the Mercury standard library for the Java
# implementation. Users should be able to run programs in grade Java without
# any architecture-specific objects.
.PHONY: jars
jars: classes
jar cf $(STD_LIB_NAME).jar mercury/*.class
jar cf $(STD_LIB_NAME).runtime.jar mercury/runtime/*.class
-+cd mercury/runtime && mmake $(NATIVE_SO)
-cp mercury/runtime/$(NATIVE_SO) .
# This shared object is needed to run some of the standard library methods.
NATIVE_SO = Native.$(EXT_FOR_SHARED_LIB)
#-----------------------------------------------------------------------------#
@@ -404,6 +416,7 @@ realclean_local:
rm -f liblibrary.$A liblibrary.so library.init
rm -f $($(STD_LIB_NAME).mods:%=%.h)
rm -f tags
rm -f $(JARS) $(NATIVE_SO)
#-----------------------------------------------------------------------------#
@@ -486,10 +499,15 @@ else
ifneq (,$(findstring java,$(GRADE)))
# Copy the jars and NATIVE_SO to INSTALL_JAVA_LIBRARY_DIR. Ignore the exit
# status of last command, since NATIVE_SO may not be available and is not
# essential.
.PHONY: install_library
install_library: jars
mkdir -p $(INSTALL_JAVA_LIBRARY_DIR)
cp $(JARS) $(INSTALL_JAVA_LIBRARY_DIR)
-cp $(NATIVE_SO) $(INSTALL_JAVA_LIBRARY_DIR)/$(FULLARCH)
else

12
library/benchmarking.m
View File

@@ -701,6 +701,18 @@ repeat(N) :-
Time = (int) (1000 * System::Diagnostics::Counter::GetElapsed());
").
*/
:- pragma foreign_proc("Java",
get_user_cpu_miliseconds(Time::out), [will_not_call_mercury],
"
if (mercury.runtime.Native.isAvailable()) {
Time = mercury.runtime.Native.get_user_cpu_miliseconds();
} else {
throw new java.lang.RuntimeException(
""get_user_cpu_miliseconds is not "" +
""implemented in pure Java. Native "" +
""dynamic link library is required."");
}
").
/*
** To prevent the C compiler from optimizing the benchmark code

53
library/time.m
View File

@@ -255,8 +255,18 @@ time__clock(Result, IO0, IO) :-
.UserProcessorTime.Ticks;
}").
*/
% XXX Java implementation still to come, will require some native code.
:- pragma foreign_proc("Java", time__c_clock(Ret::out, _IO0::di, _IO::uo),
[will_not_call_mercury, promise_pure, tabled_for_io],
"
if (mercury.runtime.Native.isAvailable()) {
Ret = mercury.runtime.Native.clock();
} else {
throw new java.lang.RuntimeException(
""time__clock is not implemented "" +
""in pure Java. Native dynamic link "" +
""library is required."");
}
").
%-----------------------------------------------------------------------------%
@@ -273,7 +283,18 @@ time__clock(Result, IO0, IO) :-
// TicksPerSecond is guaranteed to be 10,000,000
Ret = (int) System.TimeSpan.TicksPerSecond;
}").
% XXX Java implementation still to come, will require some native code.
:- pragma foreign_proc("Java", time__clocks_per_sec = (Ret::out),
[will_not_call_mercury, promise_pure],
"
if (mercury.runtime.Native.isAvailable()) {
Ret = mercury.runtime.Native.clocks_per_sec();
} else {
throw new java.lang.RuntimeException(
""time__clocks_per_sec is not implemented "" +
""in pure Java. Native dynamic link "" +
""library is required."");
}
").
%-----------------------------------------------------------------------------%
@@ -312,7 +333,31 @@ time__times(Tms, Result, IO0, IO) :-
MR_update_io(IO0, IO);
}").
% XXX Java implementation still to come, will require some native code.
:- pragma foreign_proc("Java",
time__c_times(Ret::out, Ut::out, St::out, CUt::out,
CSt::out, _IO0::di, _IO::uo),
[will_not_call_mercury, promise_pure, tabled_for_io],
"
if (mercury.runtime.Native.isAvailable()) {
int[] times = mercury.runtime.Native.times();
if (times != null) {
Ret = times[0];
Ut = times[1];
St = times[2];
CUt = times[3];
CSt = times[4];
} else {
throw new java.lang.RuntimeException(
""time_times failed to construct "" +
""integer array"");
}
} else {
throw new java.lang.RuntimeException(
""time__times is not implemented "" +
""in pure Java. Native dynamic link "" +
""library is required."");
}
").
%-----------------------------------------------------------------------------%