¿Cómo se ejecutan guiones jython multiproceso desde Java?

Question

Estoy construyendo un marco en Java que escuchará eventos y luego los procesará en Jython. Se enviarán diferentes tipos de eventos a diferentes scripts.

Dado que jython tarda bastante tiempo en compilar la secuencia de comandos cuando se llama a PythonInterpreter.exec(), tendré que precompilar las secuencias de comandos. Lo estoy haciendo la siguiente manera:

// initialize the script as string (would load it from file in final version) 
String script = "print 'foo'"; 
// get the compiled code object 
PyCode compiled = org.python.core.__builtin__.compile(script, "<>", "exec"); 

El objeto PyCode compilado sería empujado al repositorio y se utiliza como eventos vienen en

PythonInterpreter pi = new PythonInterpreter(); 
pi.set("variable_1", "value_1"); 
pi.set("variable_x", "value_x"); 
pi.exec(compiled); 

Ahora para mi dilema - que podría suceder que hay múltiples eventos de cierto tipo que suceden al mismo tiempo; por lo tanto, varias instancias de script se ejecutan al mismo tiempo.

Casi todas las secuencias de comandos probablemente seguirán siendo efímeras: hasta 100 líneas, sin bucles. El número y la frecuencia son completamente aleatorios (eventos generados por el usuario) y pueden ser de 0 a aproximadamente 200 por segundo por tipo de evento.

¿Cuál sería la mejor manera de hacerlo? Estoy viendo algunas posibilidades:

1. uso de sincronización en el punto de evento de disparo - esto impediría varias instancias del mismo guión, sino también eventos no sería procesado tan pronto como deberían ser
2. crear una agrupación del mismo tipo de scripts poblados de alguna manera al clonar el objeto PyCode original - el mayor problema sería optimizar los tamaños del grupo
3. clonar dinámicamente el objeto del script del padre siempre que sea necesario y luego descartarlo cuando exec() finalice - de esta forma se elimina el retraso de compilar pero todavía está presente en el método de clonación

Probablemente la combinación de los números 2 y 3 sería la mejor: ¿creará tamaños de grupo dinámicos?

¿Alguna idea? ;)

Answer 1

Es una pena que las instancias PyCode no sean inmutables (hay muchos miembros públicos en las clases).

Puede precompilar un guión reutilizable utilizando este código:

// TODO: generate this name 
final String name = "X"; 
byte[] scriptBytes = PyString.to_bytes(script); 
CompilerFlags flags = Py.getCompilerFlags(); 
ByteArrayOutputStream ostream = new ByteArrayOutputStream(); 
Module.compile(parser.parse(new ByteArrayInputStream(scriptBytes), "exec", 
    "<>", flags), ostream, name, "<>", false, false, false, flags); 
byte[] buffer = ostream.toByteArray(); 
Class<PyRunnable> clazz = BytecodeLoader.makeClass(name, null, buffer); 
final Constructor<PyRunnable> constructor = clazz 
    .getConstructor(new Class[] { String.class }); 

A continuación, puede utilizar el constructor para producir casos PyCode para el script siempre que lo necesite:

PyRunnable r = constructor.newInstance(name); 
PyCode pc = r.getMain(); 

que sería el Primero, admitir que esta no es una buena forma de hacer las cosas y, probablemente, lo dice todo sobre mi inexperiencia con Jython. Sin embargo, es significativamente más rápido que compilar todo el tiempo. El código funciona bajo Jython 2.2.1, pero no se compilará en Jython 2.5 (ni lo hará el tuyo).

Answer 2

PythonInterpreter es caro, este código usará solo uno.

#action.py 
def execute(filename, action_locals): 
    #add caching of compiled scripts here 
    exec(compile(open(filename).read(), filename, 'exec'), action_locals) 

//class variable, only one interpreter 
PythonInterpreter pi; 

//run once in init() or constructor 
pi = new PythonInterpreter();//could do more initialization here 
pi.exec("import action"); 

//every script execution 
PyObject pyActionRunner = pi.eval("action.execute"); 
PyString pyActionName = new PyString(script_path); 
PyDictionary pyActionLocals = new PyDictionary(); 
pyActionLocals.put("variable_1", "value_1"); 
pyActionLocals.put("variable_x", "value_x") 
pyActionRunner.__call__(pyActionName, pyActionLocals); 

#example_script.py 
print variable_1, variable_x