Changeset 620

Timestamp:

08/02/10 03:57:57 (18 months ago)

Author:

mooneer

Message:

1. Reenabled increment optimization, a 5% max improvement on top of the previous changes. It probably improved things very little when first implemented.
2. Added thread locking around parser entry points to ensure only a single thread can touch the text segment at a time.

Location:

interpreter/trunk/backend

Files:

• common/kite_compiler.c (modified) (4 diffs)
• kite-vm-1.0/kite_compile_bytecode.c (modified) (4 diffs)

interpreter/trunk/backend/common/kite_compiler.c

@@ -103 +103 @@
     }
     
+    #ifdef WIN32
+    WaitForSingleObject(thd->vm->compile_mtx, INFINITE);
+    #else
+    pthread_mutex_lock(&thd->vm->compile_mtx);
+    #endif /* WIN32 */
+    
     compiler->thd = thd;
     compiler->currentLine = 1;
@@ -126 +132 @@
     free(compiler);
 #endif /* HAVE_GC_H */
+
+    #ifdef WIN32
+    ReleaseMutex(thd->vm->compile_mtx);
+    #else
+    pthread_mutex_unlock(&thd->vm->compile_mtx);
+    #endif /* WIN32 */
+    
     return ret;
 }
@@ -164 +177 @@
     }
 
+    #ifdef WIN32
+    WaitForSingleObject(thd->vm->compile_mtx, INFINITE);
+    #else
+    pthread_mutex_lock(&thd->vm->compile_mtx);
+    #endif /* WIN32 */
+    
     compiler->thd = thd;
     compiler->currentLine = ln;
@@ -187 +206 @@
     free(compiler);
 #endif /* HAVE_GC_H */
-    return ret;
-}
+
+    #ifdef WIN32
+    ReleaseMutex(thd->vm->compile_mtx);
+    #else
+    pthread_mutex_unlock(&thd->vm->compile_mtx);
+    #endif /* WIN32 */
+
+    return ret;
+}

interpreter/trunk/backend/kite-vm-1.0/kite_compile_bytecode.c

@@ -26 +26 @@
 static void kite_optimize_increment(kite_compiler_t *compiler, kite_opcode_t *o1, kite_opcode_t *o2)
 {
-    /*kite_thread_t *thd = compiler->thd;
-    kite_opcode_push *p1 = (kite_opcode_push*)o1;
-    kite_opcode_push *p2 = (kite_opcode_push*)o2;
-    if (o1->opcode == PUSH && o2->opcode == PUSH) {
-        if (p1->obj->type == OBJ_IDENT && p2->obj->type == OBJ_IDENT) {
-            if (strcmp(p1->obj->builtin_data.stringvalue.string,
-                       p2->obj->builtin_data.stringvalue.string) == 0) {
-                if (o1->next && o2->next) {
-                    if (o1->next->opcode == DEREF_1 && o2->next->opcode == DEREF_1) {
-                        if (o1->next->next == o2) {
-                            kite_opcode_t *dupe = kite_compile_dupe_top(TRUE);
-                            dupe->file = strdup(o2->file);
-                            dupe->line = o2->line;
-                            o1->next->next = dupe;
-                            dupe->next = o2->next->next;
-                            o2->next->next = NULL;
-                            kite_free_instruction_list(thd, o2);
-                        }
+    kite_thread_t *thd = compiler->thd;
+    kite_vm_t *vm = thd->vm;
+    kite_opcode_t *p1 = (void*)vm->text_segment + (long)o1;
+    kite_opcode_t *p2 = (void*)vm->text_segment + (long)o2;
+    if (p1->opcode == PUSH && p2->opcode == PUSH) {
+        if (p1->op_arg.obj->type == OBJ_IDENT && p2->op_arg.obj->type == OBJ_IDENT) {
+            if (strcmp(p1->op_arg.obj->builtin_data.stringvalue.string,
+                       p2->op_arg.obj->builtin_data.stringvalue.string) == 0) {
+                if ((p1 + 1) < ((void*)vm->text_segment + vm->text_segment_length) &&
+                    (p1 + 2) < ((void*)vm->text_segment + vm->text_segment_length)) {
+                    if ((p1 + 1)->opcode == DEREF_1 && (p2 + 1)->opcode == DEREF_1) {
+                        p2->opcode = DUPE_TOP;
+                        p2->op_arg.dupe_ref = TRUE;
+                        (p2 + 1)->opcode = NOP;
                     }
                 }
             }
         }
-    }*/
+    }
 }
 
@@ -524 +520 @@
         
     if (opc->opcode == ARITH_OP && ((kite_opcode_arithop*)opc)->op_arg.operation == OP_ARRAY_DEREF)
-        return opc - compiler->thd->vm->text_segment;
+        return (void*)opc - (long)compiler->thd->vm->text_segment;
     else
         return NULL;
@@ -532 +528 @@
 {
     kite_opcode_t *op2;
-    
-    /*if (op1 && op1->next && op1->next->next) 
+    int has_possible_dupe = TRUE;
+    int i;
+    kite_vm_t *vm = compiler->thd->vm;
+    
+    /* Ensure next two instructions are valid for dupe optimization. 
+       Equivalent to op1 && op1->next && op1->next->next in old code. */
+    op2 = (void*)vm->text_segment + (long)op1;
+    for (i = 0; i < 2; i++)
     {
-        op2 = op1->next->next;
+        if (op2->opcode == RETURN_NOW || ((void*)op2 - (long)vm->text_segment) >= vm->text_segment_length)
+        {
+            has_possible_dupe = FALSE;
+            break;
+        }
+        op2++;
+    }
+    
+    /* Perform dupe optimization. */
+    if (has_possible_dupe)
+    {
+        op2 = (void*)op2 - (long)vm->text_segment;
         kite_optimize_increment(compiler, op1, op2);
-    }*/
+    }
     
     if (!orig_op2)
@@ -772 +785 @@
 {
     kite_thread_t *thd = compiler->thd;
+    kite_vm_t *vm = thd->vm;
     kite_opcode_t *op = kite_compile_push(kite_new_ident(thd, name));
     COMPILE_INSTRUCTION(op, line);
+    op = vm->cur_text_segment - sizeof(kite_opcode_t);
     COMPILE_INSTRUCTION(kite_compile_deref_1(TRUE), line);
-    return NULL;
+    return op;
 }