PDF de programación - Invocar programas ASM desde Java paso a paso

INVOCAR PROGRAMAS ASM DESDE JAVA PASO A PASO

Contenido

1. Introducción
2. ¿Cuándo usar JNI?
3. Requerimientos de software
4. Configuración del ambiente de trabajo
5. La programación
6. La ejecución
7. Conclusión
8. Referencias y lecturas

1. Introducción

En el sitio de java.net existe un pequeño tutorial titulado Invoking Assembly Language

Programs from Java1 pero está en inglés y no es muy sencillo para algunos nuevos
programadores Java o ensamblador. En java.net explican cómo funciona la invocación de un
programa ASM desde Java y qué hacer para lograrlo, pero no explican cómo hacer cada
paso. Por lo tanto me he dado a la tarea de facilitar la comprensión de estas técnicas para
los hispanohablantes que dan sus primeros pasos con JNI; ya que conocer un poco del
funcionamiento de JNI y la invocación de aplicaciones en ensamblador es fundamental
cuando se tienen aplicaciones que necesiten operaciones que consuman mucho proceso del
servidor y se necesite implementar un pequeño programa a bajo nivel para ejecutar tales
operaciones, y de esta manera disminuir el tiempo de espera que a veces suele ser crítico.
También con JNI tenemos la capacidad de invocar funciones y procedimientos escritos en
otros lenguajes, como C/C++ o en nuestro caso ASM, por ejemplo, cuando se tienen
sistemas legados y se necesite utilizar alguna función del código legado será necesario
desarrollar aplicaciones que puedan ejecutar estas funciones. Para más información de JNI y
sus capacidades se puede consultar el manual para programadores disponible en el sitio de
Sun2.

Cabe señalar que este no es un tutorial introductorio a JNI o al API, por lo tanto se

limitará a mencionar solo algunos conceptos necesarios. De forma rápida, comenzaremos
con determinar el software que usaremos y de dónde obtenerlo, pero no nos detendremos a
aprender el funcionamiento de ellos. Posteriormente agregaremos algunas variables de
entorno y comenzaremos con la programación. Para esto, se presentan los programas y
cómo compilarlos, sin embargo estará disponible el código fuente usado en el tutorial. Al
finalizar el tutorial el lector deberá ser capaz de cargar una librería DLL en cualquier
aplicación Java y usar los procedimientos de cualquier librería nativa.

2. ¿Cuándo usar JNI?

En algunas ocasiones, a algunos desarrolladores les tocará encontrarse en situaciones en

las que una aplicación hecha completamente en Java no cubrirá todos los requerimientos
para tal. Algunos ejemplos de estas situaciones pueden ser:

• Cuando a pesar de querer escribir toda la aplicación en Java para permitir la

compatibilidad entre plataformas, exiten características de la plataforma que son
necesarias para la aplicación y no son soportadas por la librería estándar de Java.
Esto es referido como dependencia de la plataforma.

• Cuando ya se tiene una librería escrita en algún otro lenguaje y se desea hacerla

accesible a nuestro código Java, por ejemplo, al tener que trabajar con código
legacy. en estos casos las librerías se cargan dentro del mismo proceso de la
apliación por medio de JNI, aunque existen otros mecanismos más eficientes que
funcionan en procesos separados.

• Si se quiere implementar porciones de código en un lenguaje de bajo nivel como

ensamblador para disminuir el tiempo de procesamiento. Por ejemplo, en
aplicaciones que necesiten renderizar gráficos 3D que requieren más tiempo de
procesamiento, habrá que escribir una librería para gráficos en lenguaje
ensamblador para tener un mejor rendimiento3.

• En casos en los que quiera cargar una librería nativa en un proceso existente para

evitar el costo de iniciar un nuevo proceso y cargar la librería en el mismo4.

• También será oportuno usar JNI cuando se quiera utilizar algunas funcionalidades

de un programa Java desde un código nativo.

3. Requerimientos de software

Para desarrollar los ejemplos se estará trabajando sobre un sistema operativo Windows

XP de 32 bits. El software adicional que se usará son los siguientes:

1. Editor. Servirá para editar el código Java y el código del programa ensamblador

(ASM). Para esto puede ser de gran utilidad cualquier editor de texto o algunos más
sofisticados como Notepad++5 , o IDEs especializados. Yo uso Eclipse con un plugin
para editar archivos ASM, pero también funcionan NetBeans y el VisualStudio.

2. MASM326. Se necesita para compilar los programas ASM.
3. Java7. Se debe tener instalado alguna versión del JDK de Java; preferentemente
versión 4 o posterior para evitar posibles incompatibilidades en nuestro código.

4. Configuración del ambiente de trabajo

Antes de comenzar a programar será oportuno asegurarse de tener algunas variables

entorno8 necesarias para poder ejecutar algunas instrucciones desde la ventana de
comandos sin la necesidad de almacenar el código dentro de los directorios que contienen
los comandos/programas que serán invocados.

Pasos generales para agregar variables de entorno.

• Presionar Win+Pausa para abrir las propiedades del sistema.
• En la ficha 'Opciones avanzadas' clic en el botón 'Variables de entorno' (Imagen 1).

Imagen 1. Ficha Opciones avanzadas de Propiedades del sistema

• En la nueva ventana (Imagen 2) clic en el botón 'Nueva' de la sección 'Variables del

sistema'.

Imagen 2. Variables de entorno

• En la ventana emergente 'Nueva variable del sistema' (Imagen 3) poner el nombre

de la variable y la ubicación de la carpeta de la variable.

Imagen 3. Ventana de agregar Nueva variable de sistema

Se procederá a agregar las siguientes variables de entorno:

1. Nombre de variable: JAVA_HOME
• Valor: La dirección donde se encuentra instalado Java ( C:\Archivos de

programa\Java\jdk1.5.0_04 )

2. Nombre de variable: MASM32

• Valor: La dirección donde se encuentra instalado Masm32 ( C:\masm32 )
3. Edite la variable 'Path' agregándole lo siguiente al valor de la variable:
• ;%JAVA_HOME%\bin;%MASM32%\bin
4. Para asegurarse que se han agregado correctamente las variables de entorno,
• java -version para verificar la versión de Java que está siendo usada
• ml para asegurarse que reconoce el comando correspondiente al compilador de

ejecutar las siguientes instrucciones:

Masm32. Dado que el comando no tiene una opción para mostrar solo la versión del
compilador, lo que se desplegará en la pantalla será un error que previamente
mostrará la versión del compilador.
• link / con la diagonal, como si fuese a agregar parámetros, para evitar que se
desplegue en la pantalla las opciones del linker. De igual manera, se verá en la
pantalla un error que previamente mostrará la versión del enlazador.

En la Imagen 4 se puede apreciar el resultado de las ejecuciones una tras otra. Si en vez
de obtener los resultados esperados como se observan en la imagen se lanza un error con el
mensaje "<comando>" no se reconoce como un comando interno o externo, programa
o archivo por lotes ejecutable, entonces probablemente se ha agregado
incorrectamente la variable de entorno y deberá ser necesario volver sobre los pasos para
hallar el error.

Imagen 4. Comprobación de las variables de entorno

Luego de haber agregado las variables de entorno se selecciona 'Aceptar' en las dos
ventanas emergentes anteriores para guardar todos los cambios.

5. La programación

Ahora todo está listo y ya se puede comenzar a programar. Pero antes de hacerlo,

primero deberemos poder hacer una recreación mental del diseño de nuestra aplicación y
los pasos que deberemos seguir para lograrlo. De forma general y rápida, en la Imagen 5
vemos un pequeño diseño de la estructura de la aplicación y la dinámica de las
invocaciones.

Imagen 5. Dinámica de la invocación de métodos nativos con JNI

En la Imagen 6 apreciamos un diagrama de los pasos a llevar a cabo para crear y poner

en marcha nuestro ejemplo. Para comprender en qué consiste la técnica que usaremos
explicaremos rápidamente cada uno de los pasos que deberemos llevar a cabo.

1. Crear la clase que declara los métodos nativos. En este paso es donde hacemos

nuestra aplicación Java o simplemente escribimos la clase donde hemos de declarar
todos los métodos nativos que usaremos en nuestra aplicación. Puede ser, por
ejemplo, una sola clase que se dedique exclusivamente para este efecto.

2. Usar javac para compilar el programa. Una vez que se tiene la clase que declara

los métodos nativos, es necesario compilarla. En este punto deberemos detenernos
un poco para entender que aunque no existan las librerías que contienen los
métodos nativos, Java podrá compilar el código, pero de ninguna manera se podrá
ejecutar la aplicación porque ocurrirá un error en tiempo de ejecución al intentar
cargar la librería con tales funciones.
3. Usar javah -jni para generar la cabecera de C. Este paso es crucial, ya que con
esta instrucción podremos generar un archivo .h que nos indicará el nombre y los
parámetros con los que deberán ser nombradas y parametrizadas cada una de las
funciones que vayamos a implementar en lenguaje ensamblador.

4. Escribir el programa en ensamblador que implemente los métodos nativos. Con la
especificación de los nombres solo queda implementar nuestra funcionalidad.
5. Usar masm32 para compilar el código nativo. Entre todas las herramientas que

contiene el programa masm32, necesitaremos especialmente el que nos ayuda a
compilar programas ASM con el que ensamblaremos un archivo objeto con el que
más adelante obtendremos nuestra librería nativa.
6. Usar la herramienta masm32 para generar la librería nativa. Finalmente, para tener
todos los archivos necesarios para ejecutar nuestra aplicación, deberemos generar
la librería nativa, en este caso un DLL, que cargará nuestro programa Java. Para
llevar a cabo este paso también se usará una herramienta disponible en masm32.

7. Correr la aplicación usando el intérprete de Java. Ahora, llegando a este paso, ya
podremos ejecutar nuestra aplicación como lo haríamos con cualquier aplicación
Java, tomando en cuenta que deberemos tener la librería nativa que hemos
genera