accelerate for OUT ins

port/linux/.vscode/launch.json

@@ -11,7 +11,7 @@
             "program": "${workspaceFolder}/build/test/pikascript_test",
             // "program": "${workspaceFolder}/build/boot/demo06-pikamain/pikascript_demo06-pikamain",
             "args": [
-                "--gtest_filter=PikaMath.*"
+                // "--gtest_filter=PikaMath.*"
             ],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",

port/linux/test/pikaMain-test.cpp

@@ -483,15 +483,17 @@ TEST(pikaMain, prime_100) {
     obj_run(pikaMain,
             "num = 0\n"
             "i = 2\n"
-            "for i in range(2 , 100):\n"
+            "while i < 100:\n"
             "    j=2\n"
             "    is_prime = 1\n"
-            "    for j in range(2 , i):\n"
+            "    while j < i:\n"
             "        if i%j==0 :\n"
             "            is_prime = 0\n"
             "            break\n"
+            "        j+=1\n"
             "    if is_prime:\n"
             "        num = num + i\n"
+            "    i+=1\n"
             "\n");
     /* collect */
     int num = obj_getInt(pikaMain, "num");

port/linux/test/stack-test.cpp

@@ -33,9 +33,9 @@ TEST(stack, arg) {
     stack_pushArg(&s, arg1);
     stack_pushArg(&s, arg2);
     stack_pushArg(&s, arg3);
-    Arg* arg4 = stack_popArg(&s);
-    Arg* arg5 = stack_popArg(&s);
-    Arg* arg6 = stack_popArg(&s);
+    Arg* arg4 = stack_popArg_alloc(&s);
+    Arg* arg5 = stack_popArg_alloc(&s);
+    Arg* arg6 = stack_popArg_alloc(&s);
     EXPECT_EQ(arg_getInt(arg4), 30);
     EXPECT_EQ(arg_getInt(arg5), 20);
     EXPECT_EQ(arg_getInt(arg6), 10);

src/PikaVM.c

@@ -356,17 +356,17 @@ static Arg* VM_instruction_handler_SLC(PikaObj* self,
         return arg_newNull();
     }
     if (arg_num_input == 2) {
-        Arg* key = stack_popArg(&vs->stack);
-        Arg* obj = stack_popArg(&vs->stack);
+        Arg* key = stack_popArg_alloc(&vs->stack);
+        Arg* obj = stack_popArg_alloc(&vs->stack);
         Arg* res = __vm_get(self, key, obj);
         arg_deinit(key);
         arg_deinit(obj);
         return res;
     }
     if (arg_num_input == 3) {
-        Arg* end = stack_popArg(&vs->stack);
-        Arg* start = stack_popArg(&vs->stack);
-        Arg* obj = stack_popArg(&vs->stack);
+        Arg* end = stack_popArg_alloc(&vs->stack);
+        Arg* start = stack_popArg_alloc(&vs->stack);
+        Arg* obj = stack_popArg_alloc(&vs->stack);
         Arg* res = __vm_slice(self, end, obj, start, 1);
         arg_deinit(end);
         arg_deinit(obj);
@@ -375,8 +375,8 @@ static Arg* VM_instruction_handler_SLC(PikaObj* self,
     }
     return arg_newNull();
 #else
-    Arg* key = stack_popArg(&vs->stack);
-    Arg* obj = stack_popArg(&vs->stack);
+    Arg* key = stack_popArg_alloc(&vs->stack);
+    Arg* obj = stack_popArg_alloc(&vs->stack);
     Arg* res = __vm_get(self, key, obj);
     arg_deinit(key);
     arg_deinit(obj);
@@ -431,7 +431,7 @@ static Arg* VM_instruction_handler_REF(PikaObj* self,
     Arg* arg = NULL;
     if (data[0] == '.') {
         /* find host from stack */
-        Arg* host_obj = stack_popArg(&(vs->stack));
+        Arg* host_obj = stack_popArg_alloc(&(vs->stack));
         if (argType_isObject(arg_getType(host_obj))) {
             arg = arg_copy_noalloc(obj_getArg(arg_getPtr(host_obj), data + 1),
                                    arg_return_stack);
@@ -632,7 +632,7 @@ static int VMState_loadArgsFromMethodArg(VMState* vs,
             /* clear the variable arg name */
             arg_name = strsCopy(&buffs, "");
         }
-        Arg* call_arg = stack_popArg(&(vs->stack));
+        Arg* call_arg = stack_popArg_alloc(&(vs->stack));
         call_arg = arg_setName(call_arg, arg_name);
         /* load the variable arg */
         if (PIKA_TRUE == is_get_variable_arg) {
@@ -700,11 +700,11 @@ static Arg* _vm_create_list_or_tuple(PikaObj* self,
     stack_init(&stack);
     /* load to local stack to change sort */
     for (int i = 0; i < arg_num; i++) {
-        Arg* arg = stack_popArg(&(vs->stack));
+        Arg* arg = stack_popArg_alloc(&(vs->stack));
         stack_pushArg(&stack, arg);
     }
     for (int i = 0; i < arg_num; i++) {
-        Arg* arg = stack_popArg(&stack);
+        Arg* arg = stack_popArg_alloc(&stack);
         __vm_List_append(list, arg);
         arg_deinit(arg);
     }
@@ -755,12 +755,12 @@ static Arg* VM_instruction_handler_DCT(PikaObj* self,
     stack_init(&stack);
     /* load to local stack to change sort */
     for (int i = 0; i < arg_num; i++) {
-        Arg* arg = stack_popArg(&(vs->stack));
+        Arg* arg = stack_popArg_alloc(&(vs->stack));
         stack_pushArg(&stack, arg);
     }
     for (int i = 0; i < arg_num / 2; i++) {
-        Arg* key_arg = stack_popArg(&stack);
-        Arg* val_arg = stack_popArg(&stack);
+        Arg* key_arg = stack_popArg_alloc(&stack);
+        Arg* val_arg = stack_popArg_alloc(&stack);
         __vm_Dict_set(dict, val_arg, arg_getStr(key_arg));
         arg_deinit(key_arg);
         arg_deinit(val_arg);
@@ -798,7 +798,7 @@ static Arg* VM_instruction_handler_RUN(PikaObj* self,
     if (data[0] == 0) {
         if (VMState_getInputArgNum(vs) < 2) {
             /* return arg directly */
-            return_arg = stack_popArg(&(vs->stack));
+            return_arg = stack_popArg_alloc(&(vs->stack));
             goto exit;
         }
         /* create a tuple */
@@ -831,7 +831,7 @@ static Arg* VM_instruction_handler_RUN(PikaObj* self,
             }
         }
         for (int i = 0; i < arg_num; i++) {
-            stack_tmp[i] = stack_popArg(&(vs->stack));
+            stack_tmp[i] = stack_popArg_alloc(&(vs->stack));
         }
         host_arg = stack_tmp[arg_num - 1];
         if (argType_isObject(arg_getType(host_arg))) {
@@ -1018,7 +1018,9 @@ static Arg* VM_instruction_handler_OUT(PikaObj* self,
                                        VMState* vs,
                                        char* data,
                                        Arg* arg_return_stack) {
-    Arg* outArg = stack_popArg(&(vs->stack));
+    arg_newStackBuff(outArg_stack, PIKA_ARG_BUFF_SIZE);
+    Arg* outArg = stack_popArg(&vs->stack, &outArg_stack);
+    // Arg* outArg = stack_popArg_alloc(&vs->stack);
     ArgType outArg_type = arg_getType(outArg);
 
     if (_checkLReg(data)) {
@@ -1132,13 +1134,9 @@ static Arg* VM_instruction_handler_JEZ(PikaObj* self,
     int jmp_expect = fast_atoi(data);
     arg_newStackBuff(pika_assertArg_stack, PIKA_ARG_BUFF_SIZE);
     Arg* pika_assertArg =
-        stack_popArg_noalloc(&(vs->stack), &pika_assertArg_stack);
+        stack_popArg(&(vs->stack), &pika_assertArg_stack);
     int pika_assert = arg_getInt(pika_assertArg);
-    if (pika_assertArg == &pika_assertArg_stack) {
-        arg_deinitHeap(pika_assertArg);
-    } else {
-        arg_deinit(pika_assertArg);
-    }
+    arg_deinit(pika_assertArg);
     vs->ireg[thisBlockDeepth] = !pika_assert;
 
     if (0 == pika_assert) {
@@ -1192,11 +1190,11 @@ static Arg* VM_instruction_handler_OPT(PikaObj* self,
     arg_newStackBuff(arg2_stack, PIKA_ARG_BUFF_SIZE);
     if (input_arg_num == 2) {
         /* tow input */
-        arg2 = stack_popArg_noalloc(&(vs->stack), &arg2_stack);
-        arg1 = stack_popArg_noalloc(&(vs->stack), &arg1_stack);
+        arg2 = stack_popArg(&(vs->stack), &arg2_stack);
+        arg1 = stack_popArg(&(vs->stack), &arg1_stack);
     } else if (input_arg_num == 1) {
         /* only one input */
-        arg2 = stack_popArg_noalloc(&(vs->stack), &arg2_stack);
+        arg2 = stack_popArg(&(vs->stack), &arg2_stack);
         arg1 = NULL;
     }
     ArgType type_arg1 = arg_getType(arg1);
@@ -1471,16 +1469,8 @@ static Arg* VM_instruction_handler_OPT(PikaObj* self,
         goto OPT_exit;
     }
 OPT_exit:
-    if (arg1 == &arg1_stack) {
-        arg_deinitHeap(arg1);
-    } else {
-        arg_deinit(arg1);
-    }
-    if (arg2 == &arg2_stack) {
-        arg_deinitHeap(arg2);
-    } else {
-        arg_deinit(arg2);
-    }
+    arg_deinit(arg1);
+    arg_deinit(arg2);
     if (NULL != outArg) {
         return outArg;
     }
@@ -1551,7 +1541,7 @@ static Arg* VM_instruction_handler_RET(PikaObj* self,
                                        Arg* arg_return_stack) {
     /* exit jmp signal */
     vs->jmp = VM_JMP_EXIT;
-    Arg* return_arg = stack_popArg(&(vs->stack));
+    Arg* return_arg = stack_popArg_alloc(&(vs->stack));
     method_returnArg(vs->locals->list, return_arg);
     return NULL;
 }
@@ -1560,7 +1550,7 @@ static Arg* VM_instruction_handler_RIS(PikaObj* self,
                                        VMState* vs,
                                        char* data,
                                        Arg* arg_return_stack) {
-    Arg* err_arg = stack_popArg(&(vs->stack));
+    Arg* err_arg = stack_popArg_alloc(&(vs->stack));
     PIKA_RES err = (PIKA_RES)arg_getInt(err_arg);
     VMState_setErrorCode(vs, err);
     arg_deinit(err_arg);
@@ -1703,11 +1693,7 @@ static int pikaVM_runInstructUnit(PikaObj* self,
     return_arg =
         VM_instruct_handler_table[instruct](self, vs, data, &return_arg_stack);
     if (NULL != return_arg) {
-        if (return_arg == &return_arg_stack) {
-            stack_pushArg_noalloc(&(vs->stack), return_arg);
-        } else {
-            stack_pushArg(&(vs->stack), return_arg);
-        }
+        stack_pushArg(&(vs->stack), return_arg);
     }
     goto nextLine;
 nextLine:
@@ -2123,7 +2109,7 @@ void byteCodeFrame_print(ByteCodeFrame* self) {
 void VMState_solveUnusedStack(VMState* vs) {
     uint8_t top = stack_getTop(&(vs->stack));
     for (int i = 0; i < top; i++) {
-        Arg* arg = stack_popArg(&(vs->stack));
+        Arg* arg = stack_popArg_alloc(&(vs->stack));
         ArgType type = arg_getType(arg);
         if (type == ARG_TYPE_NONE) {
             arg_deinit(arg);

src/PikaVersion.h

@@ -2,4 +2,4 @@
 #define PIKA_VERSION_MINOR       0
 #define PIKA_VERSION_MICRO       0
 
-#define PIKA_EDIT_TIME      "2022/07/30 18:59:05"
+#define PIKA_EDIT_TIME      "2022/08/01 10:06:47"

src/dataArg.c

@@ -57,7 +57,7 @@ static Arg* arg_init_hash(Hash nameHash,
     self->size = size;
     self->name_hash = nameHash;
     self->type = type;
-    self->is_serialized = PIKA_TRUE;
+    self->serialized = PIKA_TRUE;
     __platform_memset(arg_getContent(self), 0,
                       aline_by(size, sizeof(uint32_t)));
     if (NULL != content) {
@@ -81,7 +81,7 @@ void arg_init_stack(Arg* self, uint8_t* buffer, uint32_t size) {
     self->size = size;
     self->type = ARG_TYPE_UNDEF;
     self->name_hash = 0;
-    self->is_serialized = PIKA_FALSE;
+    self->serialized = PIKA_FALSE;
 }
 
 uint32_t arg_totleSize(Arg* self) {
@@ -335,7 +335,7 @@ Arg* arg_copy_noalloc(Arg* arg_src, Arg* arg_dict) {
     if (ARG_TYPE_OBJECT == arg_type) {
         obj_refcntInc((PikaObj*)arg_getPtr(arg_src));
     }
-    arg_dict->is_serialized = PIKA_FALSE;
+    arg_dict->serialized = PIKA_FALSE;
     arg_dict = arg_setContent(arg_dict, arg_getContent(arg_src),
                               arg_getContentSize(arg_src));
     arg_dict = arg_setNameHash(arg_dict, arg_getNameHash(arg_src));
@@ -414,8 +414,14 @@ exit:
 }
 
 void arg_deinit(Arg* self) {
+    if (NULL == self) {
+        return;
+    }
     /* deinit arg pointed heap */
     arg_deinitHeap(self);
+    if (!self->serialized) {
+        return;
+    }
     /* free the ref */
     arg_freeContent(self);
 }

src/dataArg.h

@@ -63,7 +63,7 @@ struct Arg {
     };
     uint32_t size;
     uint8_t type;
-    PIKA_BOOL is_serialized;
+    PIKA_BOOL serialized;
     Hash name_hash;
     uint8_t content[];
 };
@@ -131,7 +131,7 @@ uint8_t argType_isObject(ArgType type);
 #define arg_getNext(self) ((self)->next)
 #define arg_getSize(self) ((self)->size)
 #define arg_getContent(self) \
-    ((self)->is_serialized ? (self)->content : ((self)->buffer))
+    ((self)->serialized ? (self)->content : ((self)->buffer))
 #define arg_getNext(self) ((self)->next)
 #define arg_setNext(self, __next) ((self)->next = (__next))
 

src/dataArgs.c

@@ -87,7 +87,14 @@ PIKA_RES args_setStr(Args* self, char* name, char* strIn) {
 }
 
 PIKA_RES args_pushArg(Args* self, Arg* arg) {
-    link_addNode(self, arg);
+    Arg* new_arg = NULL;
+    if (!arg->serialized) {
+        new_arg = arg_copy(arg);
+        arg_deinit(arg);
+    } else {
+        new_arg = arg;
+    }
+    link_addNode(self, new_arg);
     return PIKA_RES_OK;
 }
 
@@ -299,6 +306,9 @@ PIKA_RES __updateArg(Args* self, Arg* argNew) {
     arg_setNext((Arg*)priorNode, (Arg*)nodeToUpdate);
     goto exit;
 exit:
+    if (!argNew->serialized) {
+        return PIKA_RES_OK;
+    }
     arg_freeContent(argNew);
     return PIKA_RES_OK;
 }

src/dataStack.c

@@ -74,14 +74,14 @@ void stack_pushPyload(Stack* stack, Arg* content, size_t size) {
         while (1) {
         }
     }
-    if (content->is_serialized) {
+    if (content->serialized) {
         __platform_memcpy(stack->sp, content, size);
     } else {
         __platform_memcpy(stack->sp, content, sizeof(Arg));
         __platform_memcpy(stack->sp + sizeof(Arg), content->buffer,
                           size - sizeof(Arg));
         /* transfer to serialized form */
-        ((Arg*)stack->sp)->is_serialized = PIKA_TRUE;
+        ((Arg*)stack->sp)->serialized = PIKA_TRUE;
     }
     stack->sp += size;
 }
@@ -115,10 +115,9 @@ static int32_t _stack_pushArg(Stack* stack, Arg* arg, PIKA_BOOL is_alloc) {
 }
 
 int32_t stack_pushArg(Stack* stack, Arg* arg) {
-    return _stack_pushArg(stack, arg, PIKA_TRUE);
-}
-
-int32_t stack_pushArg_noalloc(Stack* stack, Arg* arg) {
+    if (arg->serialized) {
+        return _stack_pushArg(stack, arg, PIKA_TRUE);
+    }
     return _stack_pushArg(stack, arg, PIKA_FALSE);
 }
 
@@ -147,16 +146,16 @@ Arg* _stack_popArg(Stack* stack, Arg* arg_dict, PIKA_BOOL is_alloc) {
     return arg;
 }
 
-Arg* stack_popArg(Stack* stack) {
+Arg* stack_popArg_alloc(Stack* stack) {
     return _stack_popArg(stack, NULL, PIKA_TRUE);
 }
 
-Arg* stack_popArg_noalloc(Stack* stack, Arg* arg_dict) {
+Arg* stack_popArg(Stack* stack, Arg* arg_dict) {
     return _stack_popArg(stack, arg_dict, PIKA_FALSE);
 }
 
 char* stack_popStr(Stack* stack, char* outBuff) {
-    Arg* arg = stack_popArg(stack);
+    Arg* arg = stack_popArg_alloc(stack);
     strcpy(outBuff, arg_getStr(arg));
     arg_deinit(arg);
     return outBuff;

src/dataStack.h

@@ -43,9 +43,8 @@ int32_t stack_deinit(Stack* stack);
 int32_t stack_pushStr(Stack* stack, char* str);
 char* stack_popStr(Stack* stack, char* outBuff);
 int32_t stack_pushArg(Stack* stack, Arg* arg);
-int32_t stack_pushArg_noalloc(Stack* stack, Arg* arg);
-Arg* stack_popArg(Stack* stack);
-Arg* stack_popArg_noalloc(Stack* stack, Arg* arg_dict);
+Arg* stack_popArg_alloc(Stack* stack);
+Arg* stack_popArg(Stack* stack, Arg* arg_dict);
 int32_t stack_getTop(Stack* stack);
 int32_t stack_init(Stack* stack);
 int32_t stack_popSize(Stack* stack);