1 / 37

ScriptBasic Segéd Modulok

ScriptBasic Segéd Modulok. Peter Verh á s 2002 március 5. Tartalom. Többszálú programozás Memória kezelő modul Változó kezelés Szimbólum tábla kezelés Naplózó modul, többszálú programozás. Többszálú programozás. Szálak, ( thread ) egyszerre futnak Közös memória terület

donagh
Télécharger la présentation

ScriptBasic Segéd Modulok

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. ScriptBasic Segéd Modulok Peter Verhás 2002 március 5.

  2. Tartalom • Többszálú programozás • Memória kezelő modul • Változó kezelés • Szimbólum tábla kezelés • Naplózó modul, többszálú programozás

  3. Többszálú programozás • Szálak, (thread) egyszerre futnak • Közös memória terület • Zárak, szemaforok • Processzek: külön memória terület • thread.c UNIX és NT közös implementáció

  4. Miért kell a többszálú programozás? • Szerver több klienssel akiket egyszerre szolgál ki • Kiszolgálás közben vannak lassú, inaktív részek • Nagy számítás igényű feladat többprocesszoros gépen

  5. Hogyan lehet egy szálat elindítani? int thread_CreateThread( PTHREADHANDLE pThread, void *pStartFunction, void *pThreadParameter ); • Visszatérési érték: hiba kód • Egyéb paraméterek

  6. Mi a MUTEX? • Váltóbot • Pontosan egy valaki foghatja meg • Sorban lehet rá várni • MUTual EXclusive

  7. Megosztott zár • Többen foghatják olvasásra • Csak egyvalaki foghatja meg írásra, és közben senki sem olvashatja • Sorban lehet várni rá • Házi feladat: hogyan kell megvalósítani megosztott zárat MUTEXekkel?

  8. Körbevárás • Egy feladathoz két vagy több zár kell, A és B • P1 szál fogja A-t és vár B-re, P2 szál fogja B-t és vár A-ra • Megoldás: zár fa struktúra, fentről lefelé haladunk

  9. Multi-thread vs. multi-process? • NT, VMS-en gyorsabb szálat létrehozni • UNIX-on is valamivel gyorsabb • Linux-on nincsenek igazi szálak! • Pl.: minden szálnak van külön PID-je • Core dump megöli az egész processzt

  10. Memória kezelő modul • myalloc.c • Szegmens fogalma • Memória csorgás megszüntetése, fontossága

  11. Memória modulok struktúrája typedef struct _AllocUnit { unsigned long Size; /* size of the chunk */ struct _AllocUnit *next; /* link to the next unit */ struct _AllocUnit *prev; /* the previous unit */ unsigned char memory[1]; /* one or more bytes reserved */ } AllocUnit, *pAllocUnit; • Fontos-e, hogy mi van közvetlenül a memory[1] mező előtt? (Alignment) • Miért nem memory[0]? • Hordozható ez a kód?

  12. Memória „class” struct typedef struct _MyAlloc { #if MTHREAD MUTEX mxSegment; #endif void * (*memory_allocating_function)(size_t); void (*memory_releasing_function)(void *); unsigned long MaxSize,CurrentSize, MaxNetSize,MinNetSize; pAllocUnit FirstUnit; } MyAlloc, *pMyAlloc;

  13. Fontosabb memória kezelő függvények • alloc_InitSegment • alloc_SegmentLimit • alloc_FreeSegment • alloc_FinishSegment • alloc_Alloc • alloc_Free • alloc_Merge

  14. ScriptBasic váltózók • Nem típusos nyelv: A = 1 A = 2.3 A = ”55” A[13] = 63 A = undef Ref A = V Három alaptípus, tömb, hash (ami tömb) és referencia bármelyike lehet egy adott változó értéke.

  15. Referencia értékű változók • Egy változó egy másikra mutat • Explicit referencia REF utasítással • Függvény argumentum ha lehet akkor referencia érték sub test(L) L = 3 end sub G = 1 test G print G sub test(L) ByVal L L = 3 end sub G = 1 test G print G sub test(L) L = 3 end sub G = 1 test ByVal G print G 3 1 1

  16. Változó struktúra 1/2 typedef struct _FixSizeMemoryObject { union _fsmoval{ PBYTE pValue; // the value of the object long lValue; // the long value of the object double dValue;// the double value of the object struct _FixSizeMemoryObject **aValue; } Value; unsigned long Size; // the actual size used // (may be different from the size indicated by the type) BYTE sType; //index to the array SizeOfType. // If this is LARGE_BLOCK_TYPE then //Size is the memory allocated for the value BYTE vType; // the variable type, VTYPE_/LONG/DOUBLE/STRING/REF BYTE State; // state of the variable (mortal, free or assigned)

  17. Változó struktúra 2/2 // these two pointers help to maintain // either the free list or the mortal lists // a variable can never be in a free and in a mortal list at the same time // in case of reference variable these fields maintain a linked list of // variables referencing the same value struct _FixSizeMemoryObject *next; // link to the next object union { struct _FixSizeMemoryObject *prev; // link to the previous object struct _FixSizeMemoryObject **rprev; // link to the previous variable referencing }link; long ArrayLowLimit, ArrayHighLimit; // If this is an array then these fields tell you where to start // and where to end } FixSizeMemoryObject, *pFixSizeMemoryObject;

  18. Változók Tárolása FSMO .Value.dValue = 3.3 FSMO FSMO .Value.lValue = 3 .Value.pValue .Size=67 This is a string with possible \0 character or any characters inside

  19. Változó „osztály” struct typedef struct _MemoryObject { // SizeOfType[i] is the size of the type i unsigned long SizeOfType[MAX_NUMBER_OF_FIX_TYPES]; // the number of fix length type memory objects // we can have at most MAX_NUMBER_OF_FIX_TYPES fix size types BYTE iNumberOfFixTypes; // LARGE_BLOCK_TYPE means large block which is not stored in free list BYTE FirstStringIndex,LastStringIndex; pFixSizeMemoryObjectMemoryObjectsFreeList[MAX_NUMBER_OF_FIX_TYPES]; ...memória allokálás szokásos... unsigned long maxderef;// 1000 by default } MemoryObject, *pMemoryObject;

  20. Változó allokálás • malloc/free feleslegesen drága • Kis méretű változókra (<1024) szabad lista van fenntartva • sType mondja meg a lefoglalt méretet

  21. Átmeneti változók • „Mortal” lista • Amikor befejeződik egy kifejezés kiértékelése a mortal lista elemei felszabadulnak

  22. Változó felszabadítás • Ha nem létezne referencia változó, könnyű lenne az élet • Referencia változóval két lehetséges megoldás van: • Referencia számláló • Visszahivatkozási lánc • Nincs GC ScriptBasic-ben

  23. Referencia változó beállítása 1/3 • memory_SetRef() A legegyszerűbb eset: REF P2 = P1 p2 vType=VTYPE_REF aValue rprev next p1 vType=VTYPE_LONG lValue=3 rprev next aValueszükséges, hogy P2 = ”aa” megváltoztassa p1->Value.lValue értéket next szükséges a referenciák felfűzéséhez (következő diák)

  24. Referencia változó beállítása 2/3 Bonyolultabb eset: REF P3 = P2 p3 vType=VTYPE_REF aValue rprev next p2 vType=VTYPE_REF aValue rprev next p1 vType=VTYPE_LONG lValue=3 rprev next

  25. Referencia változó beállítása 3/3 Még bonyolultabb eset: REF P4 = P3 REF P3 = P2 p4 vType=VTYPE_REF aValue rprev next p3 vType=VTYPE_XXX REF xValueaValue rprev next p2 vType=VTYPE_REF aValue rprev next p1 vType=VTYPE_LONG lValue=3 rprev next

  26. Referencia változó beállítása 3/3 Még bonyolultabb eset: REF P4 = P3 REF P3 = P2 p4 vType=VTYPE_REF aValue rprev next p3 vType=VTYPE_XXX REF xValueaValue rprev next p2 vType=VTYPE_REF aValue rprev next p1 vType=VTYPE_LONG lValue=3 rprev next

  27. Változó törlése referenciákkal undef P1 p4 vType=VTYPE_REF aValue rprev next p3 vType=VTYPE_REF aValue rprev next p2 vType=VTYPE_REF aValue rprev next p1 p1 vType=VTYPE_LONG lValue=3 rprev next memory_ReleaseVariable()

  28. Referencia változó törlése referenciákkal undef P2 p4 vType=VTYPE_REF aValue rprev next p3 vType=VTYPE_REF aValue rprev next p2 vType=VTYPE_REF aValue rprev next p1 vType=VTYPE_LONG lValue=3 rprev next

  29. Mi a helyzet ciklikus körbehivatkozásnál? undef A vType=VTYPE_REF aValue rprev next REF A[0] = A undef A 0 Ismert váltózó memória vesztési hiba. Csak számításigényes GC algoritmussal lehet kiküszöbölni. A program végén felszabadul a memória. A vType=VTYPE_ARRAY aValue rprev next

  30. Szimbólum tábla kezelés • sym.c The dragon book: Aho-Sethi-Ulman : Compilers Principles, techniques, and Tools Addison-Wesley Publishing Company 1986 • Akit érdekel nézze meg egyénileg a sym.c fájlban, és értse meg, hogy mit csinál a program.

  31. Naplózó modul • Tipikus és egyszerű aszinkron programozási feladat • Lehet rajta többszálú programozást tanulni • Sok köze nincs a ScriptBasic-hez

  32. Naplózás általában • Kétféle naplózási feladat • Informatív naplózás, például web szerver access log • Tranzakciós naplózás • Szinkron és aszinkron naplózás

  33. Naplózó modul • logger.c • Szinkron és aszinkron naplózás • A szinkron naplózás érdektelen, egyszerű, primitív

  34. Aszinkron naplózás • Gyorsan átadjuk a naplózandó elemet, és majd valaki kiírja • Aszinkron szálon futó kiíró modul • UNIX syslog [másik] gépre UDP-n • Nincs garancia, hogy nem vész el log • Nem várakoztatja a hívót

  35. Logger struktúra typedef struct _tLogger { char *pszFileName; char szFileName[FNMAX]; FILE *fp; long LastTime; // the hour of the log was written last time long TimeSpan; ...memória függvények szokásos... long MaxItemLen; // the maximal length of a log line ptLogItem QueueStart,QueueEnd; MUTEX mxChain; MUTEX mxRun; MUTEX mxState; int type; // 0 normal or 3 synchronous logger int state; // 0 normal, 1 currently shutting down, // 2 finished, closed, dead // 3 this is a synchronous logger } tLogger,*ptLogger;

  36. mxRun mxChain Hogyan működik az aszinkron naplózás log_thread

  37. Köszönöm a figyelmet.

More Related