Add support for profiling interpreted code

src/gap.c

@@ -1360,6 +1360,9 @@ Obj FuncKERNEL_INFO(Obj self) {
   tmp = MakeImmString( SyKernelVersion );
   r = RNamName("KERNEL_VERSION");
   AssPRec(res,r,tmp);
+  tmp = INTOBJ_INT(GAP_KERNEL_API_VERSION);
+  r = RNamName("KERNEL_API_VERSION");
+  AssPRec(res, r, tmp);
   tmp = MakeImmString( SyBuildVersion );
   r = RNamName("BUILD_VERSION");
   AssPRec(res,r,tmp);

src/gapstate.h

@@ -60,6 +60,10 @@ typedef struct GAPState {
     UInt   SymbolStartPos;
     UInt   SymbolStartLine;
 
+    // Used for recording the first line of the fragment of code currently
+    // begin interpreted, so the current line is outputted when profiling
+    UInt InterpreterStartLine;
+
     const Char * Prompt;
 
     Char * In;

src/hookintrprtr.h

@@ -73,9 +73,11 @@ extern void (*OriginalPrintExprFuncsForHook[256])(Expr expr);
 
 struct InterpreterHooks {
     void (*visitStat)(Stat stat);
+    void (*visitInterpretedStat)(Int line, Int pos);
     void (*enterFunction)(Obj func);
     void (*leaveFunction)(Obj func);
     void (*registerStat)(Stat stat);
+    void (*registerInterpretedStat)(Int line, Int pos);
     const char * hookName;
 };
 
@@ -122,17 +124,17 @@ void DeactivatePrintHooks(struct PrintHooks * hook);
 ** variable to avoid race conditions.
 */
 
-#define GAP_HOOK_LOOP(member, argument)                                      \
+#define GAP_HOOK_LOOP(member, ...)                                           \
     do {                                                                     \
-        Int i;                                                               \
+        Int                       i;                                         \
         struct InterpreterHooks * hook;                                      \
         for (i = 0; i < HookCount; ++i) {                                    \
             hook = activeHooks[i];                                           \
             if (hook && hook->member) {                                      \
-                (hook->member)(argument);                                    \
+                (hook->member)(__VA_ARGS__);                                 \
             }                                                                \
         }                                                                    \
-    } while(0)
+    } while (0)
 
 static inline void VisitStatIfHooked(Stat stat)
 {
@@ -155,6 +157,14 @@ static inline void RegisterStatWithHook(Stat func)
     GAP_HOOK_LOOP(registerStat, func);
 }
 
+static inline void InterpreterHook(Int file, Int line, Int skipped)
+{
+    GAP_HOOK_LOOP(registerInterpretedStat, file, line);
+    if (!skipped) {
+        GAP_HOOK_LOOP(visitInterpretedStat, file, line);
+    }
+}
+
 
 /****************************************************************************
 **

src/intrprtr.c

@@ -26,6 +26,7 @@
 #include "funcs.h"
 #include "gapstate.h"
 #include "gvars.h"
+#include "hookintrprtr.h"
 #include "integer.h"
 #include "io.h"
 #include "lists.h"
@@ -82,8 +83,32 @@
 */
 /* TL: UInt IntrCoding; */
 
+// INTERPRETER_PROFILE_HOOK deals with profiling of immediately executed
+// code.
+// If STATE(IntrCoding) is true, profiling is handled by the AST
+// generation and execution. Otherwise, we always mark the line as
+// read, and mark as executed if STATE(IntrReturning) and STATE(IntrIgnoring)
+// are both false.
+#define INTERPRETER_PROFILE_HOOK()                                           \
+    if (!STATE(IntrCoding)) {                                                \
+        InterpreterHook(GetInputFilenameID(), STATE(InterpreterStartLine),   \
+                        STATE(IntrReturning) || STATE(IntrIgnoring));        \
+    }                                                                        \
+    STATE(InterpreterStartLine) = 0;
+
+
+// Put the profiling hook into SKIP_IF_RETURNING, as this is run in
+// (nearly) every part of the interpreter, avoid lots of extra code.
+#define SKIP_IF_RETURNING()                                                  \
+    INTERPRETER_PROFILE_HOOK();                                              \
+    SKIP_IF_RETURNING_NO_PROFILE_HOOK();
+
+// Need to
+#define SKIP_IF_RETURNING_NO_PROFILE_HOOK()                                  \
+    if (STATE(IntrReturning) > 0) {                                          \
+        return;                                                              \
+    }
 
-#define SKIP_IF_RETURNING() if ( STATE(IntrReturning) > 0 ) { return; }
 #define SKIP_IF_IGNORING()  if ( STATE(IntrIgnoring)  > 0 ) { return; }
 
 
@@ -377,7 +402,7 @@ void            IntrFuncCallEnd (
     UInt                i;              /* loop variable                   */
 
     /* ignore or code                                                      */
-    SKIP_IF_RETURNING();
+    SKIP_IF_RETURNING_NO_PROFILE_HOOK();
     SKIP_IF_IGNORING();
     if ( STATE(IntrCoding)    > 0 ) {
       CodeFuncCallEnd( funccall, options, nr );
@@ -609,6 +634,9 @@ Int            IntrIfEndBody (
 {
     UInt                i;              /* loop variable                   */
 
+    /* explicitly check interpreter hooks, as not using SKIP_IF_RETURNING  */
+    INTERPRETER_PROFILE_HOOK();
+
     /* ignore or code                                                      */
     if ( STATE(IntrReturning) > 0 ) { return 0; }
     if ( STATE(IntrIgnoring)  > 0 ) { STATE(IntrIgnoring)--; return 0; }

src/io.c

@@ -54,14 +54,21 @@
 **  terminated by the character '\0'.  Because 'line' holds  only part of the
 **  line for very long lines the last character need not be a <newline>.
 **
+**  'stream' is non-zero if the input points to a stream.
+**
+**  'sline' contains the next line from the stream as GAP string.
+**
+**  The following variables are used to store the state of the interpreter
+**  and stream when another input file is opened:
+**
 **  'ptr' points to the current character within that line.  This is not used
 **  for the current input file, where 'In' points to the  current  character.
 **
 **  'number' is the number of the current line, is used in error messages.
 **
-**  'stream' is none zero if the input points to a stream.
+**  'interpreterStartLine' is the number of the line where the fragment of
+**  code currently being interpreted started. This is used for profiling
 **
-**  'sline' contains the next line from the stream as GAP string.
 **
 */
 typedef struct {
@@ -72,6 +79,7 @@ typedef struct {
     Char   line[32768];
     Char * ptr;
     UInt   symbol;
+    Int    interpreterStartLine;
     Int    number;
     Obj    stream;
     UInt   isstringstream;
@@ -537,6 +545,7 @@ UInt OpenInputStream(Obj stream, UInt echo)
         GAP_ASSERT(IS_CHAR_PUSHBACK_EMPTY());
         IO()->Input->ptr = STATE(In);
         IO()->Input->symbol = STATE(Symbol);
+        IO()->Input->interpreterStartLine = STATE(InterpreterStartLine);
     }
 
     /* enter the file identifier and the file name                         */
@@ -561,6 +570,7 @@ UInt OpenInputStream(Obj stream, UInt echo)
     STATE(In) = IO()->Input->line;
     STATE(In)[0] = STATE(In)[1] = '\0';
     STATE(Symbol) = S_ILLEGAL;
+    STATE(InterpreterStartLine) = 0;
     IO()->Input->number = 1;
 
     /* indicate success                                                    */
@@ -602,6 +612,7 @@ UInt CloseInput ( void )
     IO()->Input = IO()->InputStack[sp - 1];
     STATE(In) = IO()->Input->ptr;
     STATE(Symbol) = IO()->Input->symbol;
+    STATE(InterpreterStartLine) = IO()->Input->interpreterStartLine;
 
     /* indicate success                                                    */
     return 1;

src/modules.h

@@ -40,7 +40,7 @@
 **
 */
 
-#define GAP_KERNEL_MAJOR_VERSION 4
+#define GAP_KERNEL_MAJOR_VERSION 5
 #define GAP_KERNEL_MINOR_VERSION 0
 #define GAP_KERNEL_API_VERSION                                               \
     ((GAP_KERNEL_MAJOR_VERSION)*1000 + (GAP_KERNEL_MINOR_VERSION))