Lua vs Embedded Lisp y otros posibles candidatos. para el procesamiento de datos basado en conjuntos

Opción actual: lua-jit. Impresionantes puntos de referencia, me estoy acostumbrando a la sintaxis. Escribir un ABI de alto rendimiento requerirá una cuidadosa consideración sobre cómo estructuraré mi C++.

Otras Cuestiones de interés

1. Gambito-C y Guile como lenguajes embebibles
2. Consejos de rendimiento de Lua (tener la opción de ejecutar con un recopilador deshabilitado, y llamar al recopilador al final de una(s) ejecución (es) de procesamiento siempre es un opcion).

Antecedentes

Estoy trabajando en un sistema de procesamiento de eventos de alto volumen (complejo) en tiempo real. Tengo un DSL que representa el esquema de la estructura de eventos en el origen, el formato de almacenamiento, ciertas construcciones específicas de dominio, activando eventos internos (para estructurar y conducir el procesamiento de propósito general) y codificando ciertos pasos de procesamiento que siempre ocurren.

El DSL se ve bastante similar a SQL, de hecho estoy usando berkeley db (a través de la interfaz sqlite3) para el almacenamiento a largo plazo de eventos. La parte importante aquí es que el procesamiento de eventos se realiza basado en conjuntos, como SQL. Sin embargo, he llegado a la conclusión de que no debería agregar lógica de procesamiento de propósito general al DSL, y más bien incrustar lua o lisp para cuidar de esto.

El núcleo de procesamiento se construye alrededor de boost:: asio, es multiproceso, rpc se realiza a través de búferes de protocolo, los eventos se codifican utilizando la biblioteca IO de búfer de protocolo i es decir, los eventos no están estructurados usando protocol buffer object solo usan la misma biblioteca de codificación / decodificación. Crearé un objeto de conjunto de datos que contenga filas, bastante similar a cómo un motor de base de datos almacena en conjuntos de memoria. los pasos de procesamiento en el DSL se cuidarán primero y luego se presentarán a la lógica de procesamiento de propósito general.

Independientemente del entorno de scripting embebible que use, cada subproceso en mi núcleo de procesamiento probablemente necesitará su propio entorno de lenguaje embebido (así es como lua requiere que sea por lo menos si usted está haciendo el trabajo multi-threaded).

La(s) Pregunta (s)

La elección en este momento es entre lisp ECL y lua. Teniendo en cuenta que el rendimiento y el rendimiento es un requisito importante, esto significa que se desea minimizar las asignaciones de memoria:

1. Si estuvieras en mi posición, ¿qué idioma elegirías ?

2. ¿Hay alguna alternativa que debería considerar (no sugiera idiomas que no tengan un embeddable aplicación). Javascript v8 tal vez ?

3. ¿Lisp se ajusta mejor al dominio ? No creo que lua y Lisp sean tan diferentes en términos de lo que proporcionan. Llámame: D

4. ¿Hay otras propiedades (como las de abajo) en las que debería estar pensando ?

5. Afirmo que cualquier forma de E / s de base de datos incrustada (vea el ejemplo DSL a continuación para el contexto) empequeñece la llamada al lenguaje de scripting en órdenes de magnitud, y que elegir cualquiera de los dos no agregue mucha sobrecarga al rendimiento general. Estoy en el camino correcto ? : D

Propiedades Deseadas

1. Me gustaría asignar mi conjunto de datos a una lista lisp o tabla lua y me gustaría minimizar las copias de datos redundantes. Por ejemplo, agregar una fila de un conjunto de datos a otro debería intentar usar semántica de referencia si ambas tablas tienen la misma forma.

2. Puedo garantizar que el conjunto de datos que se pasa como entrada no cambiará mientras han hecho la llamada lua / lisp. Quiero que lua y lisp no alteren el conjunto de datos también si es posible.

3. Después de que el final de la llamada incrustada de los conjuntos de datos debe ser destruido, cualquier referencia creada tendría que ser reemplazado con copias (supongo).

Ejemplo de DSL

Adjunto un DSL para su placer visual para que pueda tener una idea de lo que estoy tratando de lograr. Nota: El DSL no muestra el procesamiento de propósito general.

// Derived Events : NewSession EndSession
NAMESPACE WebEvents
{
  SYMBOLTABLE DomainName(TEXT) AS INT4;
  SYMBOLTABLE STPageHitId(GUID) AS INT8;
  SYMBOLTABLE UrlPair(TEXT hostname ,TEXT scriptname) AS INT4;
  SYMBOLTABLE UserAgent(TEXT UserAgent) AS INT4;  

  EVENT 3:PageInput
  {
    //------------------------------------------------------------//
    REQUIRED 1:PagehitId              GUID
    REQUIRED 2:Attribute              TEXT;
    REQUIRED 3:Value                  TEXT; 

    FABRRICATED 4:PagehitIdSymbol     INT8;
    //------------------------------------------------------------//

    PagehitIdSymbol AS PROVIDED(INT8 ph_symbol)
                    OR Symbolise(PagehitId) USING STPagehitId;
  }

  // Derived Event : Pagehit
  EVENT 2:PageHit
  {
    //------------------------------------------------------------//
    REQUIRED 1:PageHitId              GUID;
    REQUIRED 2:SessionId              GUID;
    REQUIRED 3:DateHit                DATETIME;
    REQUIRED 4:Hostname               TEXT;
    REQUIRED 5:ScriptName             TEXT;
    REQUIRED 6:HttpRefererDomain      TEXT;
    REQUIRED 7:HttpRefererPath        TEXT;
    REQUIRED 8:HttpRefererQuery       TEXT;
    REQUIRED 9:RequestMethod          TEXT; // or int4
    REQUIRED 10:Https                 BOOL;
    REQUIRED 11:Ipv4Client            IPV4;
    OPTIONAL 12:PageInput             EVENT(PageInput)[];

    FABRRICATED 13:PagehitIdSymbol    INT8;
    //------------------------------------------------------------//
    PagehitIdSymbol AS  PROVIDED(INT8 ph_symbol) 
                    OR  Symbolise(PagehitId) USING STPagehitId;

    FIRE INTERNAL EVENT PageInput PROVIDE(PageHitIdSymbol);
  }

  EVENT 1:SessionGeneration
  {
    //------------------------------------------------------------//
        REQUIRED    1:BinarySessionId   GUID;
    REQUIRED    2:Domain            STRING;
    REQUIRED    3:MachineId         GUID;
    REQUIRED    4:DateCreated       DATETIME;
    REQUIRED    5:Ipv4Client        IPV4;
    REQUIRED    6:UserAgent         STRING;
    REQUIRED    7:Pagehit           EVENT(pagehit);

    FABRICATED  8:DomainId          INT4;
    FABRICATED  9:PagehitId         INT8;
    //-------------------------------------------------------------//

    DomainId  AS SYMBOLISE(domain)            USING DomainName;
    PagehitId AS SYMBOLISE(pagehit:PagehitId) USING STPagehitId;

    FIRE INTERNAL EVENT pagehit PROVIDE (PagehitId);
  } 
}

Esto el proyecto es un componente de un proyecto de investigación de doctorado y es / será software libre. Si está interesado en trabajar conmigo (o contribuir) en este proyecto, por favor deje un comentario: D