Parser lento ANTLR4 generato in Python, ma veloce in Java

Question

Sto provando a convertire il formico ANTLR3 grammar in un ANTLR4 grammar, per poterlo utilizzare con il runtime antlr4-python2. Questa grammatica è un parser fuzzy C/C++.

Dopo la conversione esso (in pratica la rimozione di operatori di albero e predicati semantici/sintattica), ho generato i file python2 utilizzando:

java -jar antlr4.5-complete.jar -Dlanguage=Python2 CPPGrammar.g4

E il codice viene generato senza alcun errore, in modo da importare nel mio progetto Python (sto usando PyCharm) per fare alcuni test:

import sys, time 
from antlr4 import * 
from parser.CPPGrammarLexer import CPPGrammarLexer 
from parser.CPPGrammarParser import CPPGrammarParser 

currenttimemillis = lambda: int(round(time.time() * 1000)) 

def is_string(object): 
    return isinstance(object,str) 

def parsecommandstringline(argv): 
    if(2!=len(argv)): 
     raise IndexError("Invalid args size.") 
    if(is_string(argv[1])): 
     return True 
    else: 
     raise TypeError("Argument must be str type.") 

def doparsing(argv): 
    if parsecommandstringline(argv): 
     print("Arguments: OK - {0}".format(argv[1])) 
     input = FileStream(argv[1]) 
     lexer = CPPGrammarLexer(input) 
     stream = CommonTokenStream(lexer) 
     parser = CPPGrammarParser(stream) 
     print("*** Parser: START ***") 
     start = currenttimemillis() 
     tree = parser.code() 
     print("*** Parser: END *** - {0} ms.".format(currenttimemillis()-start)) 
     pass 

def main(argv): 
    tree = doparsing(argv) 
    pass 

if __name__ == '__main__': 
    main(sys.argv) 

Il problema è che l'analisi è molto lenta. Con un file contenente ~ 200 linee ci vogliono più di 5 minuti per completare, mentre l'analisi dello stesso file in antlrworks richiede solo 1-2 secondi. Analizzando l'albero antlrworks, ho notato che la regola expr e tutti i suoi discendenti sono chiamati molto spesso e penso che ho bisogno di semplificare/modificare queste regole per rendere il parser operare più velocemente:

È la mia ipotesi corretta o ho fatto qualche errore durante la conversione della grammatica? Cosa si può fare per rendere l'analisi veloce come su antlrworks?

UPDATE: Ho esportato la stessa grammatica in Java e sono stati necessari solo 795 ms per completare l'analisi. Il problema sembra più correlato all'implementazione di Python rispetto alla grammatica stessa. C'è qualcosa che può essere fatto per accelerare l'analisi di Python?
Ho letto here che python può essere 20-30 volte più lento di java, ma nel mio caso python è ~ 400 volte più lento!

Answer 1

Confermo che i runtime di Python 2 e Python 3 hanno problemi di prestazioni. Con alcune patch, ho ottenuto un 10x di accelerazione sul runtime python3 (~ 5 secondi fino a ~ 400 ms). https://github.com/antlr/antlr4/pull/1010

Answer 2

Ho affrontato un problema simile quindi ho deciso di confrontare questo vecchio post con una possibile soluzione. La mia grammatica funzionava all'istante con TestRig ma era incredibilmente lenta su Python 3.

Nel mio caso l'errore era il token non-goloso che stavo usando per produrre commenti di una riga (doppia barra in C/C++, '%' nel mio caso):

TKCOMM : '%' ~[\r\n]* -> skip ; 

questo è in qualche modo sostenuta da questo post da sharwell in questa discussione qui: https://github.com/antlr/antlr4/issues/658

Quando la performance è un problema, evitare di usare gli operatori non avidi, soprattutto nelle regole del parser .

Per testare questo scenario, è possibile rimuovere regole/token non grezzi dalla grammatica.