ScriptBasic Segéd Modulok

S B

ScriptBasic Segéd Modulok

Peter Verhás2002 március 5.

S BTartalom

• 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

S BTö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ó

S B 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

S B 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

S BMi a MUTEX?

• Váltóbot• Pontosan egy valaki foghatja meg• Sorban lehet rá várni

• MUTual EXclusive

S BMegosztott 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?

S BKö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

S BMulti-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

S BMemória kezelő modul

• myalloc.c• Szegmens fogalma• Memória csorgás megszüntetése,

fontossága

S BMemó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?

S BMemó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;

S B Fontosabb memória kezelő függvények

• alloc_InitSegment• alloc_SegmentLimit• alloc_FreeSegment• alloc_FinishSegment• alloc_Alloc• alloc_Free• alloc_Merge

S BScriptBasic 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.

S BReferencia é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 = 3end subG = 1test Gprint G

sub test(L) ByVal L L = 3end subG = 1test Gprint G

sub test(L) L = 3end subG = 1test ByVal Gprint G

3 1 1

S BVá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)

S BVá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;

S BVáltozók Tárolása

FSMO

.Value.dValue = 3.3

FSMO

.Value.lValue = 3FSMO

.Value.pValue

This is a string with possible \0 character or any characters inside.Size=67

S BVá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; pFixSizeMemoryObject MemoryObjectsFreeList[MAX_NUMBER_OF_FIX_TYPES];

...memória allokálás szokásos...

unsigned long maxderef;// 1000 by default } MemoryObject, *pMemoryObject;

S BVá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

S BÁtmeneti változók

• „Mortal” lista• Amikor befejeződik egy kifejezés

kiértékelése a mortal lista elemei felszabadulnak

S BVá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:

1. Referencia számláló2. Visszahivatkozási lánc

– Nincs GC ScriptBasic-ben

S BReferencia változó beállítása 1/3

• memory_SetRef()

vType=VTYPE_LONGlValue=3rprevnext

p1

vType=VTYPE_REFaValuerprevnext

p2

A legegyszerűbb eset:

REF P2 = P1

aValue szükséges, hogy P2 = ”aa” megváltoztassa p1->Value.lValue értéketnext szükséges a referenciák felfűzéséhez (következő diák)



p1


p2

Bonyolultabb eset:REF P3 = P2


p3



p1


p2

Még bonyolultabb eset:REF P4 = P3REF P3 = P2

vType=VTYPE_XXX REFxValue aValuerprevnext

p3


p4



p1


p2

Még bonyolultabb eset:REF P4 = P3REF P3 = P2

vType=VTYPE_XXX REFxValue aValuerprevnext

p3


p4

S BVáltozó törlése referenciákkal


p1


p2

undef P1


p3


p4

p1

memory_ReleaseVariable()

S B


Referencia változó törlése referenciákkal


p1


p2

p3


p4undef P2

S B Mi a helyzet ciklikus körbehivatkozásnál?

vType=VTYPE_ARRAYaValuerprevnext

A

0


undef A

REF A[0] = Aundef A

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.

S BSzimbólum tábla kezelés

• sym.cThe 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.

S BNaplózó modul

• Tipikus és egyszerű aszinkron programozási feladat

• Lehet rajta többszálú programozást tanulni

• Sok köze nincs a ScriptBasic-hez

S BNapló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

S BNaplózó modul

• logger.c• Szinkron és aszinkron naplózás• A szinkron naplózás érdektelen,

egyszerű, primitív

S BAszinkron 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

S BLogger 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;

S B Hogyan működik az aszinkron naplózás

mxRun

mxChain

log_thread

S B

Köszönöm a figyelmet.

Documents

ScriptBasic Segéd Modulok