Scriptbasic seg d modulok
This presentation is the property of its rightful owner.
Sponsored Links
1 / 37

ScriptBasic Segéd Modulok PowerPoint PPT Presentation


  • 47 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Scriptbasic seg d modulok

ScriptBasic Segéd Modulok

Peter Verhás

2002 március 5.


Tartalom

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

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ó


Mi rt kell a t bbsz l programoz s

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


Hogyan lehet egy sz lat elind tani

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


Mi a mutex

Mi a MUTEX?

  • Váltóbot

  • Pontosan egy valaki foghatja meg

  • Sorban lehet rá várni

  • MUTual EXclusive


Megosztott z r

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?


K rbev r s

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


Multi thread vs multi process

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


Mem ria kezel modul

Memória kezelő modul

  • myalloc.c

  • Szegmens fogalma

  • Memória csorgás megszüntetése, fontossága


Mem ria modulok strukt r ja

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?


Mem ria class struct

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;


Fontosabb mem ria kezel f ggv nyek

Fontosabb memória kezelő függvények

  • alloc_InitSegment

  • alloc_SegmentLimit

  • alloc_FreeSegment

  • alloc_FinishSegment

  • alloc_Alloc

  • alloc_Free

  • alloc_Merge


Scriptbasic v lt z k

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.


Referencia rt k v ltoz k

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


V ltoz strukt ra 1 2

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)


V ltoz strukt ra 2 2

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;


V ltoz k t rol sa

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


V ltoz oszt ly struct

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;


V ltoz allok l s

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


Tmeneti v ltoz k

Átmeneti változók

  • „Mortal” lista

  • Amikor befejeződik egy kifejezés kiértékelése a mortal lista elemei felszabadulnak


V ltoz felszabad t s

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


Referencia v ltoz be ll t sa 1 3

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)


Referencia v ltoz be ll t sa 2 3

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


Referencia v ltoz be ll t sa 3 3

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


Referencia v ltoz be ll t sa 3 31

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


V ltoz t rl se referenci kkal

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()


Referencia v ltoz t rl se referenci kkal

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


Mi a helyzet ciklikus k rbehivatkoz sn l

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


Szimb lum t bla kezel s

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.


Napl z modul

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


Napl z s ltal ban

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


Napl z modul1

Naplózó modul

  • logger.c

  • Szinkron és aszinkron naplózás

  • A szinkron naplózás érdektelen, egyszerű, primitív


Aszinkron napl z s

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


Logger strukt ra

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;


Hogyan m k dik az aszinkron napl z s

mxRun

mxChain

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

log_thread


Scriptbasic seg d modulok

Köszönöm a figyelmet.


  • Login