nabaztag_hack_kit 0.1.0.beta3 → 0.1.0.beta8

data/ext/mtl_linux/src/vm/vmem.c

@@ -0,0 +1,461 @@
+// VLISP Virtual Machine - 2006 - by Sylvain Huet
+// Lowcost IS Powerfull
+
+#include"vmem.h"
+#include"vloader.h"
+#include"vlog.h"
+
+void play_check(int nocb);
+
+#ifdef VSIMU
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int vmem_heap[VMEM_LENGTH];
+#endif
+
+#define VMEM_DBG
+
+
+int vmem_heapindex;
+int *vmem_top;
+int vmem_stack;
+int vmem_start;
+int vmem_broken;
+
+// initialisation de la m�moire
+void vmemInit(int start)
+{
+    vmem_top=&vmem_heap[VMEM_LENGTH];
+    vmem_stack=0;
+    vmem_start=vmem_heapindex=start;
+    vmem_broken=0;
+}
+
+void vmemSetstart(int start)
+{
+    int size;
+
+    if (start>=vmem_start-HEADER_LENGTH)
+    {
+        return;
+    }
+
+    size=((vmem_start-HEADER_LENGTH-start)<<2)-1;
+
+    vmem_heap[start]=(size<<8)+(TYPE_BINARY);
+    vmem_heap[start+HEADER_GC]=0;
+    vmem_heap[start+HEADER_LIST]=0;
+
+    vmem_start=start;
+}
+
+
+void vmemGCfirst()
+{
+    int i,k,j,n;
+    int first;
+
+    first=-1;
+    for(i=vmem_stack; i<0; i++)
+    {
+        k=vmem_top[i];
+        if ((ISVALPNT(k))&&(k!=NIL))
+        {
+            k=VALTOPNT(k);
+#ifdef VMEM_DBG
+            if ((k<0)||(k>=VMEM_LENGTH))
+            {
+                consolestr("1.k out of space\n");
+            }
+#endif
+            if (!HEADER_USED(k))
+            {
+                HEADER_MARK(k);
+                vmem_heap[k+HEADER_LIST]=first;
+                first=k;
+            }
+        }
+    }
+    while(first!=-1)
+    {
+        k=first;
+#ifdef VMEM_DBG
+        if ((k<0)||(k>=VMEM_LENGTH))
+        {
+            consolestr("1.first out of space\n");
+        }
+#endif
+        first=vmem_heap[k+HEADER_LIST];
+        if (HEADER_TYPE(k))        // bloc table
+        {
+            n=VSIZE(k);
+            j=k+HEADER_LENGTH;
+            for(i=0; i<n; i++)
+            {
+                k=vmem_heap[j+i];
+                if ((ISVALPNT(k))&&(k!=NIL))
+                {
+                    k=VALTOPNT(k);
+#ifdef VMEM_DBG
+                    if ((k<0)||(k>=VMEM_LENGTH))
+                    {
+                        consolestr("1.k2 out of space\n");
+                    }
+#endif
+                    if (!HEADER_USED(k))
+                    {
+                        HEADER_MARK(k);
+                        vmem_heap[k+HEADER_LIST]=first;
+                        first=k;
+                    }
+                }
+            }
+        }
+    }
+}
+#ifdef VMEM_DBG
+void dumpheap()
+{
+    int pos,realsize;
+#ifdef VSIMU
+    FILE *f;
+
+    f=fopen("mem.bin","wb");
+    fwrite(&vmem_start,1,4,f);
+    fwrite(&vmem_heapindex,1,4,f);
+    fwrite(&vmem_stack,1,4,f);
+    fwrite(vmem_heap,VMEM_LENGTH,1,f);
+    fclose(f);
+#endif
+    pos=vmem_start;
+
+    while(pos < vmem_heapindex)
+    {
+        realsize=VSIZE(pos)+HEADER_LENGTH;
+        consolehx(pos);
+        consolestr(":pos ");
+        consolehx(realsize);
+        consolestr(":realsize\n");
+        if ((realsize<0)||(realsize>=VMEM_LENGTH))
+        {
+            consolestr("2.realsize out of range\n");
+            dump((char*)&vmem_heap[pos-32],128);
+            return;
+        }
+        dump((char*)&vmem_heap[pos],32);
+        pos+=realsize;
+    }
+
+
+}
+#endif
+void vmemGCsecond()
+{
+    int pos,newpos,realsize;
+
+    pos=newpos=vmem_start;
+
+    while(pos < vmem_heapindex)
+    {
+        realsize=VSIZE(pos)+HEADER_LENGTH;
+#ifdef VMEM_DBG
+        if ((realsize<0)||(realsize>=VMEM_LENGTH))
+        {
+            dumpheap();
+#ifdef VSIMU
+            printf("CORE DUMP\n");
+            getchar();
+            exit(0);
+#endif
+        }
+#endif
+        if (HEADER_USED(pos))
+        {
+            vmem_heap[pos+HEADER_GC]=newpos<<1;
+            newpos+=realsize;
+        }
+        pos+=realsize;
+    }
+}
+
+void vmemGCthird()
+{
+    int i,k,j,n;
+    int first;
+
+    first=-1;
+    for(i=vmem_stack; i<0; i++)
+    {
+        k=vmem_top[i];
+        if ((ISVALPNT(k))&&(k!=NIL))
+        {
+            k=VALTOPNT(k);
+            vmem_top[i]=vmem_heap[k+HEADER_GC]|1;	// attention, hack
+            if (!HEADER_USED(k))
+            {
+                HEADER_MARK(k);
+                vmem_heap[k+HEADER_LIST]=first;
+                first=k;
+            }
+        }
+    }
+    while(first!=-1)
+    {
+        k=first;
+        first=vmem_heap[k+HEADER_LIST];
+        if (HEADER_TYPE(k))        // bloc table
+        {
+            n=VSIZE(k);
+            j=k+HEADER_LENGTH;
+            for(i=0; i<n; i++)
+            {
+                k=vmem_heap[j+i];
+                if ((ISVALPNT(k))&&(k!=NIL))
+                {
+                    k=VALTOPNT(k);
+                    vmem_heap[j+i]=vmem_heap[k+HEADER_GC]|1;	// attention, hack
+                    if (!HEADER_USED(k))
+                    {
+                        HEADER_MARK(k);
+                        vmem_heap[k+HEADER_LIST]=first;
+                        first=k;
+                    }
+                }
+            }
+        }
+    }
+}
+void vmemGCfourth()
+{
+    int pos,newpos,realsize,i;
+
+    pos=newpos=vmem_start;
+
+    while(pos < vmem_heapindex)
+    {
+        realsize=VSIZE(pos)+HEADER_LENGTH;
+        if (HEADER_USED(pos))
+        {
+            vmem_heap[pos+HEADER_GC]=0;
+            if (newpos!=pos)
+            {
+                if (newpos+realsize<=pos)
+                {
+                    memcpy(&vmem_heap[newpos],&vmem_heap[pos],realsize<<2);
+                }
+                else
+                {
+                    consolestr("########GC : BIG MOVE\n");
+                    for(i=0; i<realsize; i++)
+                    {
+                        vmem_heap[newpos+i]=vmem_heap[pos+i];
+                    }
+                }
+
+                newpos+=realsize;
+                pos+=realsize;
+//                        for(i=0;i<realsize;i++) vmem_heap[newpos++]=vmem_heap[pos++];
+            }
+            else
+            {
+                newpos=pos=pos+realsize;
+            }
+        }
+        else
+        {
+            // ## ajouter ici la gestion des types externes : if (HEADER_EXT(pos)) ...
+            pos+=realsize;
+        }
+    }
+    vmem_heapindex=newpos;
+}
+
+void vmemGC()
+{
+//  logGC();
+#ifdef VREAL
+    play_check(1);
+#endif
+    vmemGCfirst();
+#ifdef VREAL
+    play_check(1);
+#endif
+    vmemGCsecond();
+#ifdef VREAL
+    play_check(1);
+#endif
+    vmemGCthird();
+#ifdef VREAL
+    play_check(1);
+#endif
+    vmemGCfourth();
+#ifdef VREAL
+    play_check(1);
+#endif
+    logGC();
+//        dump(bytecode,32);
+}
+
+int vmemAllocBin(int size,int ext)
+{
+    int wsize,p;
+    wsize=HEADER_LENGTH+((size+4)>>2);
+
+    if (VMEM_LENGTH+vmem_stack-vmem_heapindex-wsize<VMEM_GCTHRESHOLD)
+    {
+        vmemGC();
+        if (VMEM_LENGTH+vmem_stack-vmem_heapindex-wsize<VMEM_GCTHRESHOLD)
+        {
+            consolestr("?OM Error\n");
+            vmem_broken=1;
+            sysReboot();
+            return -1;
+        }
+    }
+    p=vmem_heapindex;
+    vmem_heapindex+=wsize;
+    vmem_heap[p]=(size<<8)+((ext&127)<<1)+(TYPE_BINARY);
+    vmem_heap[p+HEADER_GC]=0;
+    vmem_heap[p+HEADER_LIST]=0;
+    vmem_heap[p+wsize-1]=0;
+    return p;
+}
+
+int vmemAllocString(char *p,int len)
+{
+    int i;
+    char *q;
+    int iq=vmemAllocBin(len,0);
+    if (iq<0)
+    {
+        return iq;
+    }
+    q=VSTARTBIN(iq);
+    for(i=0; i<len; i++)
+    {
+        q[i]=p[i];
+    }
+    return iq;
+}
+
+int vmemAllocTab(int size,int ext)
+{
+    int wsize,p;
+    wsize=HEADER_LENGTH+size;
+
+    if (VMEM_LENGTH+vmem_stack-vmem_heapindex-wsize<VMEM_GCTHRESHOLD)
+    {
+        vmemGC();
+        if (VMEM_LENGTH+vmem_stack-vmem_heapindex-wsize<VMEM_GCTHRESHOLD)
+        {
+            consolestr("?OM Error\n");
+            vmem_broken=1;
+            sysReboot();
+            return -1;
+        }
+    }
+    p=vmem_heapindex;
+    vmem_heapindex+=wsize;
+    size=(size<<2)-1;
+    vmem_heap[p]=(size<<8)+((ext&127)<<1)+(TYPE_TAB);
+    vmem_heap[p+HEADER_GC]=0;
+    vmem_heap[p+HEADER_LIST]=0;
+    vmem_heap[p+wsize-1]=0;
+    return p;
+}
+
+int vmemAllocTabClear(int size,int ext)
+{
+    int p=vmemAllocTab(size,ext);
+    if (p>=0)
+    {
+        int i;
+        for(i=0; i<size; i++)
+        {
+            vmem_heap[p+HEADER_LENGTH+i]=NIL;
+        }
+    }
+    return p;
+}
+
+int vmemPush(int val)
+{
+    vmem_top[--vmem_stack]=val;
+    if (VMEM_LENGTH+vmem_stack-vmem_heapindex<VMEM_GCTHRESHOLD)
+    {
+        vmemGC();
+        if (VMEM_LENGTH+vmem_stack-vmem_heapindex<VMEM_GCTHRESHOLD)
+        {
+            consolestr("?OM Error\n");
+            vmem_broken=1;
+            sysReboot();
+            return -1;
+        }
+    }
+    return 0;
+}
+
+void vmemStacktotab(int n)
+{
+    int *q;
+    int p=vmemAllocTab(n,0);
+    q=VSTART(p);
+    while(n>0)
+    {
+        q[--n]=VPULL();
+    }
+    VPUSH(PNTTOVAL(p));
+}
+
+
+void vmemDumpHeap()
+{
+#ifdef VSIMU
+    int i,pos,realsize,n;
+#endif
+    consolestr("HEAP\n----\n");
+#ifdef VSIMU
+    pos=vmem_start;
+    n=0;
+    while(pos < vmem_heapindex)
+    {
+        realsize=VSIZE(pos)+HEADER_LENGTH;
+        printf("%06X : %s %d\n",pos,HEADER_TYPE(pos)?"Tab":"Bin",VSIZE(pos));
+        for(i=0; i<realsize; i++)
+        {
+            printf("%x ",vmem_heap[pos+i]);
+        }
+        printf("\n");
+        pos+=realsize;
+        n++;
+    }
+#endif
+    logGC();
+}
+
+void vmemDumpStack()
+{
+#ifdef VSIMU
+    int i,k;
+#endif
+    consolestr("STACK\n-----\n");
+#ifdef VSIMU
+    for(i=-1; i>=vmem_stack; i--)
+    {
+        k=vmem_top[i];
+        printf("%d : %6x -> %6x (%d)\n",i,k,k>>1,k>>1);
+    }
+#endif
+}
+
+void vmemDump()
+{
+    vmemDumpHeap();
+    vmemDumpStack();
+}
+
+void vmemDumpShort()
+{
+    logGC();
+}