proc. Aproc. B proc. Dproc. C

(1)

,QIRUPDWLFD,, 3URJUDPPD]LRQHGL5HWHHGL6LVWHPD

/D3URJUDPPD]LRQH GL5HWHHGL6LVWHPDLLL

$FXUDGL

/XFD%UHYHJOLHUL*LDFRPR%XRQDQQR 5REHUWR1HJULQL *LXVHSSH3R]]L 'RQDWHOOD6FLXWR

DEIPoliMI0LODQR

LIUC&DVWHOODQ]DVA

EUHYHJOLHULQHJULQLSR]]LVFLXWR#HOHWSROLPLLW EXRQDQQR#OLXFLW

YHUVLRQHGHOPDU]R

/DSURJUDPPD]LRQHGLVLVWHPD

,QWURGX]LRQHDOVLVWHPDRSHUDWLYR HGLOVLVWHPDRSHUDWLYRPXOWLSURFHVVR

,OVLVWHPDRSHUDWLYR

qXQLQVLHPHGLPRGXOLVRIWZDUH

FRQWUROODOHULVRUVHGHOVLVWHPD

LQWHUDJLVFHGLUHWWDPHQWHFRQLVRIWZDUHFKH

FRQWUROODQRO¶KDUGZDUHGHYLFHGULYHU

PHWWHDGLVSRVL]LRQHGHOO¶XWHQWHXQD

PDFFKLQD³YLUWXDOH´LQJUDGRGLHVHJXLUH

FRPDQGLGDWLGDOO¶XWHQWHXWLOL]]DQGRXQD

PDFFKLQD³UHDOH´GLOLYHOORLQIHULRUHHPHQR

SRWHQWH

,OVLVWHPDRSHUDWLYR

CPU RAM

FD

HD

Scheda

rete Interf.

I/O bus Sistema operativo

Interprete comandi

(2)

,OSURFHVVRGDOSXQWRGLYLVWD

GHOVLVWHPDRSHUDWLYR

,OSURFHVVR q

XQ¶DWWLYLWjVHTXHQ]LDOHFRPHDGHV

O¶LVWDQ]DGLXQSURJUDPPDLQHVHFX]LRQH

FRQXQRVWDWRDVVRFLDWR/RVWDWRDVXD

YROWDVLGLYLGHLQ

VWDWRLQWHUQR

VWDWRHVWHUQR

LOSURFHVVRqDQFKHGHILQLWRFRPHO¶HVHFXWRUHGLXQSURJUDPPD

FUHDWRGLQDPLFDPHQWH

/RVWDWRGLXQSURFHVVR

/RVWDWRLQWHUQR LQGLFD

ODSURVVLPDLVWUX]LRQHGHOSURJUDPPDFKHGHYH

HVVHUHHVHJXLWD

LYDORULGHOOHYDULDELOLHGHLUHJLVWULXWLOL]]DWLGDO

SURFHVVR

/RVWDWRHVWHUQR LQGLFDVHLOSURFHVVRq

LQDWWHVDGLXQHYHQWRFRPHDGHVODOHWWXUDGD

GLVFRRO¶LQVHULPHQWRGLGDWLGDWDVWLHUD

LQHVHFX]LRQH

SURQWRSHUO¶HVHFX]LRQHHTXLQGLDWWHQGHGL

DFFHGHUHDOO¶XWLOL]]RGHOOD&38

,OVLVWHPDRSHUDWLYRHOH

PDFFKLQHYLUWXDOL

,OVLVWHPDRSHUDWLYR

FRQWUROODODPDFFKLQDPXOWLSURJUDPPDWD

FLRqFKHHVHJXHSLSURFHVVL

FRQWHPSRUDQHDPHQWHUHQGHQGRYLVLELOHDG

RJQLSURFHVVRXQDPDFFKLQD³YLUWXDOH´DG

HVVRLQWHUDPHQWHGHGLFDWDHTXLQGLFRQ

ULVRUVHSURSULH

,OVLVWHPDRSHUDWLYR

HARDWARE 3URFHVVRUH 0HPRULD 3HULIHULFKH

SISTEMA OPERATIVO 6

H E L L

G U I

altri pro_

gram mi

altri pro_

gram

mi PROCESSI

Servizi di Sistema

(3)

,OVLVWHPDRSHUDWLYRHOH

PDFFKLQHYLUWXDOL

Hardware e Sistema operativo Processo 1

(esecutore)

Processo 2 (esecutore)

Processo 3 (esecutore) Programma 1 Programma 2 Programma 3

,VWUX]LRQL ,VWUX]LRQL ,VWUX]LRQL

9LUWXDOL]]D]LRQH 9LUWXDOL]]D]LRQH 9LUWXDOL]]D]LRQH

,OVLVWHPDRSHUDWLYR HOHPDFFKLQHYLUWXDOL

CPU A RAM A

FD A

HD A

Rete A I/O A

proc. A

CPU B RAM B

FD B

HD B

Rete B I/O B

proc. B

CPU D RAM D

FD D

HD D

Rete D I/O D

proc. D

CPU C RAM C

FD C

HD C

Rete C I/O C

proc. C

bus

,OVLVWHPDRSHUDWLYR HODPDFFKLQDUHDOH

CPU

A, B, C, D

RAM

A B C D

HD

A B C D

FD

A B C D

Rete

A, B, C, D

I/O

A, B, C, D

bus

utilizzo a rotazione suddivisione in blocchi suddivisione in blocchi

suddivisione in blocchi utilizzo a rotazione utilizzo a rotazione

,OVLVWHPDRSHUDWLYR

JHVWLVFHHYHQWXDOLFRQIOLWWLGLDFFHVVR

FRQWHPSRUDQHRDOOHULVRUVH³UHDOL´

FRQGLYLVHDFFRGDQGRLSURFHVVLULFKLHGHQWL

$GHVXQFRPSRQHQWHGHWWRVFKHGXOHU

VHOH]LRQDLSURFHVVLLQVWDWRGLSURQWRHG

DVVHJQDORURDURWD]LRQHO¶XWLOL]]RGHOOD&38

SHUXQTXDQWRGLWHPSRGLHVHFX]LRQH

SROLWLFDGHWWDURXQGURELQ

(4)

,SURFHVVLHGLOVLVWHPD

RSHUDWLYR

$QFKHLOVLVWHPDRSHUDWLYRq

LPSOHPHQWDWRWUDPLWHSURFHVVL

LOVLVWHPDRSHUDWLYRqJDUDQWHFKHL

FRQIOLWWLWUDLSURFHVVLVLDQRFRQWUROODWLH

JHVWLWLFRUUHWWDPHQWH

LOVLVWHPDRSHUDWLYRYLHQHHVHJXLWRLQ

PRGDOLWjSULYLOHJLDWDNHUQHOPRGH R

VXSHUYLVRUFRVuGDSRWHUFRQWUROODUHJOL

DOWULSURFHVVLHVHJXLWLLQPRGDOLWjXVHU

&KLDPDWHDOVXSHUYLVRU

,SURFHVVLXWHQWHSHUHVHJXLUH

RSHUD]LRQLSULYLOHJLDWHFRPHDGHV

DFFHVVRDILOH

DFFHVVRDGDOWUHULVRUVH

RSHUD]LRQLGL,2GLUHWWR

LQYRFDQRLOVXSHUYLVRU WUDPLWHFKLDPDWH

GLVLVWHPDV\VWHPFDOOV

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

/HRSHUD]LRQLGL,2VRQRRSHUD]LRQL

ULVHUYDWH

XQSURFHVVR$ QRQGHYHSRWHUDQGDUHD

VFULYHUHPHVVDJJLVXXQWHUPLQDOHQRQ

DVVRFLDWRDOORVWHVVRSURFHVVR$

XQSURFHVVR$ QRQGHYHSRWHUOHJJHUH

FDUDWWHULLPPHVVLGDXQWHUPLQDOHQRQ

DVVRFLDWRDOORVWHVVRSURFHVVR$

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

8QSURFHVVRQRQGHYHSRWHUVFRQILQDUH

DOGLIXRULGHOSURSULRVSD]LRGL

PHPRULD

SHUQRQDFFHGHUHDOORVSD]LRGLPHPRULD

DVVRFLDWRDGXQDOWURSURFHVVR

PRGLILFDQGRFRGLFHHGDWLGLTXHVW¶XOWLPR

SHUQRQRFFXSDUHWXWWDODPHPRULD

GLVSRQLELOHQHOVLVWHPDEORFFDQGRORH

UHQGHQGRORFRVuLQXWLOL]]DELOHGDDOWUL

SURFHVVL

(5)

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

/DFRQGLYLVLRQHGLULVRUVHTXDOLDG

HVHPSLRGLVFKL&38VFKHGHGLUHWH

GHYHHVVHUHWDOHGDFDXWHODUHLGDWLGLRJQL

XWHQWH

GHYHHYLWDUHFKHXQXWHQWHRFFXSLO¶LQWHUR

VSD]LRGLVSRQLELOHVXLGLVFKLQRQODVFLDQGR

VSD]LRSHUDOWULXWHQWL

VHXQSURFHVVR$ HQWUDLQORRSFLzQRQ

GHYHEORFFDUHO¶LQWHURVLVWHPD

«HGDOWULHVHPSLDQFRUD

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

(VVHQGRXQVLVWHPDPXOWLSURJUDPPDWR

HRPXOWLXWHQWH

HYHQWXDOLFRQIOLWWLGHYRQRHVVHUHJHVWLWLGD

XQ³DUELWUR´LOVLVWHPDRSHUDWLYRFKH

IXQ]LRQLVHFRQGRUHJROHFKLDUHHEHQ

VWDELOLWH

1HFHVVLWjGLSDUDOOHOLVPR QHLVLVWHPLRSHUDWLYL

8QXWHQWHFKHVLFROOHJDDGXQD

PDFFKLQDDGHV8QL[WUDPLWHLO

SURJUDPPDWHOQHWGLVSRQHGLXQ

LQWHUSUHWHFRPDQGLHYHQWXDOPHQWH

VFHOWRGDOO¶XWHQWHVWHVVRWUDPLWHFKVK

1HOODPDFFKLQDGHYHHVVHUHSUHVHQWHXQ

SURFHVVRLQWHUSUHWHFRPDQGLSHURJQL

VHVVLRQH

1HFHVVLWjGLSDUDOOHOLVPR QHLVLVWHPLRSHUDWLYL

$GRJQLQXRYDFRQQHVVLRQHLOVLVWHPD

RSHUDWLYRJHQHUDXQSURFHVVRLQWHUSUHWH

FRPDQGLVSHFLILFRSHUTXHOOD

FRQQHVVLRQH

&LVRQRTXLQGLSLFRSLHGHOORVWHVVR

SURJUDPPD

(6)

3DUDOOHOLVPRLQ8QL[

(VLVWRQRGXHSULQFLSDOLPHWRGLSHU

RWWHQHUHO¶HVHFX]LRQHSDUDOOHODLQ

DPELHQWH8QL[

JHQHUD]LRQHGLQXRYLSURFHVVL

XWLOL]]RGLWKUHDG

&RQVLGHUHUHPRODJHQHUD]LRQHGLQXRYL

SURFHVVLPHFFDQLVPRSLVWDQGDUGH

PHQRFRPSOHVVR

/DSURJUDPPD]LRQHGLVLVWHPD

'HILQL]LRQL

'HILQL]LRQH

&RQSURJUDPPD]LRQHGLVLVWHPD VL

LQWHQGRQROHWHFQLFKHXWLOL]]DWHQHOOD

VFULWWXUDGLSURJUDPPLXWHQWHFLRqQRQ

QHFHVVDULDPHQWHHVHJXLWLLQPRGDOLWj

VXSHUYLVRUFKHLQWHUDJLVFRQR

VWUHWWDPHQWHFRQLOVLVWHPDRSHUDWLYRH

FKHXWLOL]]DQRLVHUYL]LV\VWHPFDOOV PHVVLDGLVSRVL]LRQHGDTXHVW¶XOWLPR

/HFKLDPDWHGLVLVWHPD

/HFKLDPDWHGLVLVWHPDVRQRGLYLVHQHOOH

VHJXHQWLSULQFLSDOLFDWHJRULH

JHVWLRQHGHLSURFHVVL

VHJQDOD]LRQL

JHVWLRQHGLILOH

JHVWLRQHGLGLUHWWRULHGLILOHV\VWHP

SURWH]LRQH

JHVWLRQHGLRUDHGDWD

GD7DQHQEDXP$6:RRGKXOO$:2SHUDWLQJ6\VWHPV 'HVLJQDQG,PSOHPHQWDWLRQ^QG HG3UHQWLFH+DOO

(7)

3URJUDPPD]LRQHGLVLVWHPD

$OO¶LQWHUQRGHOODSURJUDPPD]LRQHGL

VLVWHPDODQRVWUDDWWHQ]LRQHVL

IRFDOL]]HUjVXOOHSULPLWLYHLQOLQJXDJJLR

&SHU

JHVWLRQHGHJOLDFFHVVLDILOH

JHVWLRQHGLSURFHVVL

2SHUD]LRQLVXLILOH

/HSULQFLSDOLRSHUD]LRQLGLDFFHVVRDILOH

FRQVHQWRQRGL

DSULUHXQILOH

OHJJHUHXQFDUDWWHUHXQDVWULQJDXQ

EORFFRGDXQILOH

VFULYHUHXQFDUDWWHUHXQDVWULQJDXQ

EORFFRVXXQILOH

FDQFHOODUHFDPELDUHQRPHVSRVWDUHGL

GLUHWWRULRXQILOH

FKLXGHUHXQILOH

2SHUD]LRQLVXLSURFHVVL

/HSULQFLSDOLRSHUD]LRQLVXLSURFHVVL

FRQVHQWRQRGL

JHQHUDUHXQSURFHVVRILJOLRFKLOG RDQFKH

VODYHFRSLDGHOSURFHVVRSDGUHSDUHQW R

DQFKHPDVWHULQHVHFX]LRQH

DWWHQGHUHODWHUPLQD]LRQHGLXQSURFHVVRILJOLR

WHUPLQDUHXQSURFHVVRILJOLR UHVWLWXHQGRXQ

FRGLFHDOSURFHVVRSDGUH

VRVWLWXLUHLOFRGLFHGLXQSURFHVVRLQHVHFX]LRQH

/DSURJUDPPD]LRQHGLVLVWHPD

/DJHVWLRQHGHLILOH

DHVHUFLWD]LRQH

(8)

,OILOH

(¶XQFRQWHQLWRUHGLLQIRUPD]LRQL

SHUPDQHQWL

VXPHPRULDGLPDVVD

FXLVLDFFHGHWUDPLWHIXQ]LRQLGHOOD

VWDQGDUGOLEUDU\

(¶DQFKHGHWWR³ORQJOLYHGREMHFW´

,OILOH

(¶LGHQWLILFDWRGD

QRPHXQLYRFRQHOODVXDGLUHFWRU\HG

HVWHQVLRQH

GLUHFWRU\HYROXPHGRYHqPHPRUL]]DWR

OXQJKH]]DQXPHURGLE\WH

GDWDHRUDGLFUHD]LRQHHGLXOWLPRDFFHVVR

SURSULHWDULRHGXWHQWLDXWRUL]]DWLDOO¶DFFHVVR

PRGDOLWjGLDFFHVVR

OHWWXUD

VFULWWXUD

9LVXDOL]]D]LRQHGHOOHLQIRUPD]LRQL

DVVRFLDWHDGXQILOH

KRPHSR]]LWHPS!OVOSD WRWDO

GUZ[ SR]]L 6HS

GUZ[U[U[ SR]]L-XQ

UZ SR]]L 6HS 7HPD(VDPHW[W

UZ[UZ[ SR]]L6HS ([HFXWH0H

)OXVVLHILOH

8QSURJUDPPDDGHVLQ&FKHGHVLGHUD

XWLOL]]DUHXQILOHGHYHDSULUHXQIOXVVR

VWUHDPGLFRPXQLFD]LRQHLQYRFDQGRLO

VLVWHPDRSHUDWLYR

,OVLVWHPDRSHUDWLYRUHVWLWXLVFHDOSURJUDPPD

LOGHVFULWWRUHGHOILOH KDQGOHHPHPRUL]]D

VHPSUHODSRVL]LRQHFRUUHQWHQHOILOH

2JQLRSHUD]LRQHVXOILOHDYYLHQHWUDPLWH

KDQGOH$OWHUPLQHLOSURJUDPPDFKLXGHLO

ILOHULODVFLDQGRLOGHVFULWWRUH

(9)

)OXVVLHILOH

9LVRQRWUHIOXVVLVWDQGDUGDVVRFLDWLDG

RJQLSURFHVVR

VWGLQODWDVWLHUDSHUOHJJHUHLPHVVDJJLLQ

LQJUHVVRVFDQI

VWGRXWLOYLGHRSHUVFULYHUHLPHVVDJJLLQ

XVFLWDSULQWI

VWGHUULOYLGHRSHUVFULYHUHLPHVVDJJLGL

HUURUHSULQWI

$WDOLIOXVVLVLDJJLXQJRQRHYHQWXDOLILOH

DSHUWLGDOSURJUDPPD

7LSLGLILOH

'LWHVWR $6&,,

VRQRVHTXHQ]HGLFDUDWWHULJHQHUDOPHQWH

VXGGLYLVHLQOLQHHVHSDUDWHGDOFDUDWWHUH

C?Q¶

SRVVRQRHVVHUHYLVXDOL]]DWLDYLGHRDGHV

WUDPLWHLOFRPDQGRFDWRVWDPSDWLDGHV

WUDPLWHLOFRPDQGROSU

7LSLGLILOH

%LQDUL ELQDU\

VRQRVHTXHQ]HGLE\WH

SHUHVVHUHOHWWLqQHFHVVDULRFRQRVFHUHOD

PRGDOLWjVHFRQGRODTXDOHOHLQIRUPD]LRQL

VRQRVWDWHVFULWWH

JHQHUDOPHQWHQRQSRVVRQRHVVHUHOHWWLH

VWDPSDWLGLUHWWDPHQWHVHQRQWUDPLWH

RSSRUWXQLSURJUDPPL

2SHUD]LRQLGLEDVH QHOODJHVWLRQHGHLILOH

$SHUWXUDIRSHQ DSUHXQILOH

PHPRUL]]DVHPSUHODSRVL]LRQHFRUUHQWH

QHOILOH

&KLXVXUDIFORVH FKLXGHXQILOH

&DQFHOOD]LRQHUHPRYH SHUFDQFHOODUHXQ

ILOH

5LGHQRPLQD]LRQHUHQDPH PRGLILFDLO

QRPHGLXQILOHRVSRVWDUORGLGLUHWWRULR

(10)

0RGDOLWjEDVHGLDFFHVVR

/HPRGDOLWjEDVHGLDFFHVVRVRQRVSHFLILFDWH

GXUDQWHODIDVHGLDSHUWXUDGHOILOHHVRQR

/HWWXUD

UUHDG

ODSRVL]LRQHFRUUHQWHqDOO¶LQL]LRGHOILOH

6FULWWXUD

ZZULWH

ODSRVL]LRQHFRUUHQWHqDOO¶LQL]LRGHOILOH

$JJLXQWD

DDSSHQG

ODSRVL]LRQHFRUUHQWHqDOODILQHGHOILOH

$OWUHPRGDOLWjGLDFFHVVR

%LQDULR

EELQDU\

/HWWXUDHVFULWWXUD

VLDVFULWWXUDFKHOHWWXUD

(VHPSLGLPRGDOLWjGLDFFHVVR

ZZULWHLQPRGDOLWjWHVWR

ZZULWHHUHDGLQPRGDOLWjWHVWR

UEUHDGLQPRGDOLWjELQDULD

DEDJJLXQWDHOHWWXUDLQPRGDOLWjELQDULD

IRSHQ

$SHUWXUDGHOILOH

),/( IS

FRQVWFKDU IQDPH ³0LR)LOH´

FRQVWFKDU PRGH ³Z´

IS IRSHQIQDPHPRGH

IS 18//VHHUURUHGLDSHUWXUD

(11)

IFORVH

&KLXVXUDGHOILOHFKHGHYHHVVHUHVWDWR

DSHUWRSUHFHGHQWHPHQWH

),/( IS

LQWUHVXOW

UHVXOW IFORVHIS

UHVXOW VHHUURUHGLFKLXVXUD

UHPRYH

&DQFHOOD]LRQHGHOILOH

),/( IS LQXWLOHSHUODUHPRYH LQWUHVXOW

FRQVWFKDU IQDPH ³0LR)LOH´

UHVXOW UHPRYHIQDPH

UHVXOW VHHUURUHGLFDQFHOOD]LRQH

UHQDPH

5LGHQRPLQD]LRQHGHOILOH

),/( IS LQXWLOHSHUODUHQDPH FRQVWFKDU IQDPH2OG ³9HFFKLR1RPH´

FRQVWFKDU IQDPH1HZ ³1XRYR1RPH´

LQWUHVXOW

UHVXOW UHQDPHIQDPH2OGIQDPH1HZ

UHVXOW VHHUURUHGLULGHQRPLQD]

UHQDPHLL

5LGHQRPLQD]LRQHGHOILOHFRQFDPELRGL

GLUHFWRU\

),/( IS LQXWLOHSHUODUHQDPH FKDU IQDPH2OG ³0\'LU9HFFKLR´

FKDU IQDPH1HZ ³0\'LU1XRYR´

UHVXOW UHQDPHIQDPH2OGIQDPH1HZ

UHVXOW VHHUURUHGLULGHQRPLQD]

(12)

*HVWLRQHGHJOLHUURUL

QHOO¶DFFHVVRDLILOH

5DJJLXQJLPHQWRGHOODILQHGHOILOHIHRI LQGLFDVHVLqUDJJLXQWDODILQHGHOILOH

9HULILFDGLHYHQWXDOLHUURULGLDFFHVVR

IHUURU LQGLFDVHVLVRQRYHULILFDWLHUURUL

GLDFFHVVRDOILOH

&DQFHOOD]LRQHGLHYHQWXDOLHUURULGL

DFFHVVRFOHDUHUU ULSRUWDDOGHIDXOWL

YDORULGLHRI HGLHUURU SHULOILOH

IHRI

9HULILFDLOUDJJLXQJLPHQWRGHOODILQHGHO

ILOHVXXQILOHSUHFHGHQWHPHQWHDSHUWR

OHJJHQGRODYDULDELOHHRI DVVRFLDWDDIS

),/( IS

LQWUHVXOW

UHVXOW IHRIIS

UHVXOW VHILQHILOHUDJJLXQWD

IHUURU

&RQWUROODHUURULGLDFFHVVRDOILOHVXXQ

ILOHSUHFHGHQWHPHQWHDSHUWROHJJHQGR

ODYDULDELOHHUURU DVVRFLDWDDIS

),/( IS

LQWUHVXOW

UHVXOW IHUURUIS

UHVXOW VHHUURUHGLDFFHVVRDOILOH

FOHDUHUU

5LVWDELOLVFHLYDORULGLGHIDXOWSHUHRI HG

HUURU VXILOHSUHFHGHQWHPHQWHDSHUWR

),/( IS

YRLGFOHDUHUUIS

(13)

$FFHVVRGLUHWWRDLILOH

&RQVHQWH

ODPRGLILFDGHOODSRVL]LRQHFRUUHQWHQHOILOH

SUHFHGHQWHPHQWHDSHUWRTXLQGLSHUPHWWH

O¶DFFHVVRDGXQSDUWLFRODUHE\WHGHOTXDOHq

QRWDODSRVL]LRQHDOO¶LQWHUQRGHOILOH

'LVSRQHGHOOHIXQ]LRQL

IVHHN

IWHOO

UHZLQG

IVHHN

0RGLILFDGHOODSRVL]LRQHFRUUHQWHGLXQ

ILOHSUHFHGHQWHPHQWHDSHUWR

),/( IS

ORQJRIIVHW

LQWUHVXOWUHISRLQW

UHVXOW IVHHNISRIIVHWUHISRLQW

IVHHN

RIIVHW

LQGLFDORVFRVWDPHQWRHSXzDVVXPHUH

YDORULSRVLWLYLRQHJDWLYL

UHISRLQW

LQGLFDVHORVFRVWDPHQWRqUHODWLYRD

6((.B6(7LQL]LRGHOILOH

6((.B&85SRVL]LRQHFRUUHQWH

6((.B(1'ILQHGHOILOH

UHVXOW

VH LQGLFDXQHUURUHQHOO¶RSHUD]LRQH

IWHOO

5LSRUWDODSRVL]LRQHFRUUHQWHGLXQILOH

SUHFHGHQWHPHQWHDSHUWR

),/( IS

ORQJRIIVHW

RIIVHW IWHOOIS

(14)

UHZLQG

5LSRUWDDOO¶LQL]LRODSRVL]LRQHFRUUHQWHGL

XQILOHSUHFHGHQWHPHQWHDSHUWR

),/( IS

YRLGUHZLQGIS

HTXLYDOHDIVHHNIS6((.B6(7

/HWWXUDHVFULWWXUD GLFDUDWWHULVXILOH

/HWWXUDOHJJHXQFDUDWWHUHGDOILOH

SUHFHGHQWHPHQWHDSHUWR

JHWF

IJHWF

6FULWWXUDVFULYHXQFDUDWWHUHVXOILOH

SUHFHGHQWHPHQWHDSHUWR

SXWF

ISXWF

IJHWF

/HWWXUDGLXQFDUDWWHUHGDXQILOH

SUHFHGHQWHPHQWHDSHUWR

),/( IS

FKDUF

F IJHWFIS

F (2)VHILQHILOHUDJJLXQWD

ISXWF

6FULWWXUDGLXQFDUDWWHUHVXXQILOH

SUHFHGHQWHPHQWHDSHUWR

),/( IS

LQWUHVXOW

FKDUF

UHVXOW ISXWFISF

UHVXOW VHHUURUHGLVFULWWXUD

(15)

/HWWXUDHVFULWWXUD GLVWULQJKHVXILOH

/HWWXUDOHJJHXQDVWULQJDGLFDUDWWHUL

GDOILOHSUHFHGHQWHPHQWHDSHUWR

JHWV

IJHWV

6FULWWXUDVFULYHXQDVWULQJDGLFDUDWWHUL

VXOILOHSUHFHGHQWHPHQWHDSHUWR

SXWV

ISXWV

IJHWV

/HWWXUDGLXQDVWULQJDGLQ FDUDWWHULGD

XQILOHSUHFHGHQWHPHQWHDSHUWR

),/( IS

FKDU V

LQWQ

LIIJHWVVQIS 18//

^HUURUHGLOHWWXUD`

IJHWV

/¶RSHUD]LRQHGLOHWWXUDSXz

OHJJHUHQ FDUDWWHUL

OHJJHUHPHQRGLQ FDUDWWHULVHLQFRQWUDXQ

µ?Q¶

/DVWULQJDLQPHPRULDqWHUPLQDWDGD

µ?¶

6HVLLQFRQWUDHRISULPDGLDYHUOHWWRQ FDUDWWHULLFDUDWWHULOHWWLVRQRDVVHJQDWL

DV FKHWHUPLQDFRQµ?¶

ISXWV

6FULWWXUDGLXQDVWULQJDVXXQILOH

SUHFHGHQWHPHQWHDSHUWR

),/( IS

FKDU V

LQWUHVXOW

UHVXOW ISXWVVIS

UHVXOW VHHUURUHLQVFULWWXUD

(16)

/HWWXUDHVFULWWXUDGLVWUXFW

/¶RSHUD]LRQHSUHYHGHO¶DFFHVVRDILOHSHU

EORFFKL

/HWWXUDOHJJHXQEORFFRGLGDWLGDXQ

ILOHSUHFHGHQWHPHQWHDSHUWR

IUHDG

6FULWWXUDVFULYHXQEORFFRGLGDWLVXXQ

ILOHSUHFHGHQWHPHQWHDSHUWR

IZULWH

/HWWXUDHVFULWWXUDGLVWUXFW

6LLSRWL]]DVLDGDWDXQDVWUXFW GHOWLSR

W\SHGHIVWUXFW^

FKDUFRJQRPH>@

FKDUQRPH>@

LQWPDWULFROD

`VWXGHQWH

IUHDG

/HWWXUDGLXQEORFFRGLGDWLGDXQILOH

SUHFHGHQWHPHQWHDSHUWR

),/( IS

VWXGHQWHVWXG

LQWUHVXOWGLPHOHPQXPHOHP

UHVXOW IUHDG VWXGGLPHOHPQXPHOHPIS

IUHDG

VWXG

LQGLUL]]RGLVWXGHQWH

GLPHOHP

GLPHQVLRQHGHOO¶HOHPHQWR

VL]HRIVWXG

QXPHOHP

QXPHURGLHOHPHQWLGDOHJJHUH

UHVXOW

QXPHURGLHOHPHQWLHIIHWWLYDPHQWHOHWWL

6HUHVXOW QXPHOHPLQGLFDXQHUURUH

QHOO¶RSHUD]LRQH

(17)

IZULWH

6FULWWXUDGLXQEORFFRGLGDWLVXXQILOH

SUHFHGHQWHPHQWHDSHUWR

),/( IS

VWXGHQWHVWXG

LQWUHVXOWGLPHOHPQXPHOHP

UHVXOW IZULWH VWXGGLPHOHPQXQHOHP

IS

IZULWH

VWXG

LQGLUL]]RGLVWXGHQWH

GLPHOHP

GLPHQVLRQHGHOO¶HOHPHQWR

VL]HRIVWXG

QXPHOHP

QXPHURGLHOHPHQWLGDVFULYHUH

UHVXOW

QXPHURGLHOHPHQWLHIIHWWLYDPHQWHVFULWWL

6HUHVXOW QXPHOHPLQGLFDXQHUURUH

QHOO¶RSHUD]LRQH

/DSURJUDPPD]LRQHGLVLVWHPD

/DJHVWLRQHGHLSURFHVVL

0RWLYD]LRQL

8QSURFHVVRSDGUHSXzGRYHU

PDQGDUHLQHVHFX]LRQHXQDOWUR

SURFHVVRILJOLRHYHQWXDOPHQWH

VRVSHQGHQGRODSURSULDHVHFX]LRQHLQ

DWWHVDGHOODWHUPLQD]LRQHGHOSURFHVVR

ILJOLR

(VHPSLRLQWHUSUHWHFRPDQGL

(18)

$VSHWWLJHQHUDOLUHODWLYL DLSURFHVVL

2JQLSURFHVVRqLGHQWLILFDWRLQPRGR

XQLYRFRGDXQ3,'3URFHVV,'HQWLILHU

7XWWLLSURFHVVLVRQRFUHDWLGDDOWUL

SURFHVVLHTXLQGLKDQQRXQSURFHVVR

SDGUH XQLFDHFFH]LRQHLOSURFHVVRLQLW

SULPRSURFHVVRFUHDWRDOODYYLDPHQWR

GHO62FKHQRQKDXQSURFHVVRSDGUH

$VSHWWLJHQHUDOLUHODWLYL DLSURFHVVL

'DOSXQWRGLYLVWDGHOSURJUDPPDWRUHGLVLVWHPDOD

PHPRULDGLODYRURDVVRFLDWDDGXQSURFHVVRSXzHVVHUH

YLVWDFRPHFRVWLWXLWDGDVHJPHQWL

 VHJPHQWRFRGLFH WH[WVHJPHQWFRQWLHQHOHVHJXLELOHGHO

SURJUDPPD

 VHJPHQWRGDWL XVHUGDWDVHJPHQWFRQWLHQHWXWWHOHYDULDELOLGHO

SURJUDPPDJOREDOLRVWDWLFKHORFDOLDOORFDWHVXVWDFNFUHDWH

GLQDPLFDPHQWHGDOSURJUDPPDWUDPLWHPDOORF

 VHJPHQWRGLVLVWHPD V\VWHPGDWDVHJPHQWFRQWLHQHLGDWLQRQ

JHVWLWLHVSOLFLWDPHQWHGDOSURJUDPPDLQHVHFX]LRQHPDGDO62DG

HVHPSLRODWDEHOODGHLILOHDSHUWLHLGHVFULWWRULGLVRFNHW

2SHUD]LRQHVXLSURFHVVL

/HSULQFLSDOLRSHUD]LRQLVXLSURFHVVL

FRQVHQWRQRGL

JHQHUDUHXQSURFHVVR

DWWHQGHUHODWHUPLQD]LRQHGLXQSURFHVVR

WHUPLQDUHXQSURFHVVR

VRVWLWXLUHLOFRGLFHGLXQSURFHVVRLQ

HVHFX]LRQH

LOSUHVHQWHOXFLGRQHULFKLDPDXQRSUHFHGHQWH

IRUN

&UHDXQSURFHVVRILJOLRRFKLOGLGHQWLFRDO

SURFHVVRSDGUHRSDUHQW

LOILJOLRqXQDFRSLDLGHQWLFDGHOSDGUHDOO¶L

VWDQWHGHOODIRUN/HYDULDELOLLILOHDSHUWLL

VRFNHWXWLOL]]DWLVRQRGXSOLFDWL QHOILJOLR

O¶XQLFDGLIIHUHQ]DWUDILJOLRHSDGUHqOD

YDULDELOHSLG GHOSURFHVVRILJOLRJHQHUDWR

LOSDGUHFRQRVFHLOSLG GHOORILJOLRLOILJOLRQRQ

FRQRVFHLOSURSULRSLG4XLQGLQHOILJOLR

SLG

(19)

IRUN

8QSURFHVVRILJOLR) SXzDVXDYROWDJHQHUDUH

XQXOWHULRUHSURFHVVRILJOLR1

6LVWDELOLVFHFRVuXQDJHUDUFKLDGLSURFHVVL

*HUDUFKLDGLSURFHVVL

Padre P

3qSDGUHGL)H)

)qSDGUHGL1H1

)qSDGUHGL1

Figlio F1

Figlio N11

Figlio F2

Figlio N12 Figlio N2

6LQWDVVLGLIRUN

pid_t fork ()

/∗ Biforca il processo in padre e figlio:

al figlio restituisce sempre 0; al padre restituisce il pid > 0 del figlio biforcato; la funzione restituisce −1 se la biforcazione del processo fallisce (restituisce solo al padre, ovviamente, visto che il figlio non è stato biforcato), per esempio per insufficienza di memoria per la creazione del processo figlio, o altro motivo ∗/

6LQWDVVLGLIRUN LL

6LQWDVVL

SLGBWSLG IRUN UHVWLWXLVFHSLGBW SLGDVVXPHYDORUH

QHOILJOLR

QHOSDGUHVHODIRUNQRQqVWDWDHVHJXLWDDG

HVSHUPDQFDQ]DGLPHPRULD

TXDOVLDVLDOWURYDORUHQHOSDGUHLQGLFDLOSLGGHO

ILJOLR

(20)

8WLOL]]RGLIRUN

#include <stdio.h>

#include <unistd.h>

void main(int argc, char * argv[]) { pid_t pid;

int retstatus;

pid = fork();

if (pid==0) {

/* sono nel figlio*/

...

/* il figlio termina restituendo al padre lo */

/* stato di terminazione */

exit(retstatus);

} else {

/* pid != 0, sono nel padre */

} }

s_pid = fork();

if (s_pid == 0) {

compito del figlio }

else {w_pid = wait(&stato);}

seguito del padre;

Process ID = a La fork genera un

altro processo con Process ID=s_pid=b

Process ID = b, s_pid = 0 Process ID = a, s_pid = b

s_pid = fork();

if (s_pid == 0) {...}

else {w_pid = wait(&stato);

il padre attende la terminazione del figlio

};

padre

s_pid = fork();

if (s_pid == 0) {

compito del figlio exit(0);

} else {};

figlio

s_pid = fork();

if (s_pid == 0) {...}

dopo la terminazione del figlio il padre procede l’esecuzione };

Termine del processo con Process ID = b Dopo la terminazione del processo figlio

ZDLW

6RVSHQGHO¶HVHFX]LRQHGHOSURFHVVRSDGUHHG

DWWHQGHODWHUPLQD]LRQHGLXQTXDOVLDVL

SURFHVVRILJOLR

VHLOILJOLRWHUPLQDSULPDFKHLOSDGUHHVHJXD

ODZDLWO¶HVHFX]LRQHGHOODZDLW QHOSDGUH

WHUPLQDLVWDQWDQHDPHQWH

6LQWDVVLGLZDLW

pid_t wait (int * stato)

/∗ Mette un processo padre in stato di attesa dell’evento di terminazione di un processo figlio qualsiasi, e restituisce il pid del figlio effettivamente terminato; la funzione restituisce −1 se il processo padre esce dalla

"wait" per un errore che non abbia a che vedere con la terminazione di un figlio; l'argomento

“stato” assume il valore di “exit” del processo figlio terminato.

Parametri: stato è il puntatore a un intero, che conterrà lo stato di uscita del figlio terminato (contano solo gli 8 bit più significativi; gli 8 bit meno significativi vengono impostati da parte del sistema operativo stesso) ∗/

(21)

(VHPSLRGLZDLW

6LQWDVVL

P\BSLG ZDLW VWDWXV

UHVWLWXLVFHXQWLSRSLGBW QHOSDGUH

P\BSLGDVVXPHLOYDORUHGHOSLGGHOILJOLR

WHUPLQDWR

VWDWXVGLWLSRLQWHURDVVXPHLOYDORUHGHO

FRGLFHGLWHUPLQD]LRQHGHOSURFHVVRILJOLR

8WLOL]]RGLZDLW

#include <stdio.h>

#include <sys/types.h>

#include <sys/wait.h>

void main(int argc, char * argv[]) { pid_t pid, my_pid;

int status;

pid = fork();

if (pid==0) { }

else {

printf("Ho generato il processo figlio con pid %d\n",pid);

/* pid != 0, sono nel padre */

...

my_pid = wait(&status);

printf{"E’ terminato il processo %d con esito %d\n",my_pid, status/256);

} }

ZDLWSLG

6RVSHQGHO¶HVHFX]LRQHGHOSURFHVVRSDGUHHG

DWWHQGHODWHUPLQD]LRQHGHOSURFHVVRILJOLRGL

FXLYLHQHIRUQLWR LOSLGP\BSLG

VHLOILJOLRWHUPLQDSULPDFKHLOSDGUHHVHJXD

ODZDLWSLGO¶HVHFX]LRQHGHOODZDLWSLG QHO

SDGUHWHUPLQDLVWDQWDQHDPHQWH

6LQWDVVLGLZDLWSLG

pid_t waitpid (pid_t pid, int * stato, int opzioni)

/∗ Mette un processo padre in stato di attesa dell’evento di terminazione del processo figlio avente pid pari a “pid”, e ne restituisce il pid; la funzione è insensibile alla terminazione di eventuali altri figli aventi pid diverso da "pid"; la funzione restituisce −1 se il processo padre esce dalla

"waitpid" per un errore che non abbia a che vedere con la terminazione del figlio "pid"; l'argomento

“stato” assume il valore di “exit” del processo figlio terminato.

Parametri: pid è il "pid" del figlio della cui terminazione il padre si mette in attesa; stato è il puntatore a un intero, che conterrà lo stato di uscita del figlio terminato (solo gli 8 bit più significativi); opzioni è un intero che specializza la funzione “waitpid”, e di solito vale 0 (altrimenti vedere il manuale in linea della funzione, perché le opzioni possibili sono parecchie) ∗/

(22)

(VHPSLRGLZDLWSLG

6LQWDVVL

P\BSLG ZDLWSLGSLG VWDWXV

RSWLRQV UHVWLWXLVFHXQSLGBW QHOSDGUH

P\BSLGDVVXPHLOYDORUHGHOSLGGHOILJOLR

WHUPLQDWR

VWDWXVDVVXPHLOYDORUHGHOFRGLFHGLWHUPLQD]LRQH

GHOSURFHVVRILJOLR

RSWLRQVVSHFLILFDXOWHULRULRS]LRQLLSRWL]]LDPR!

8WLOL]]RGLZDLWSLG

#include <stdio.h>

void main(int argc, char * argv[]) { pid_t pid, my_pid;

int status;

pid = fork();

if (pid==0) { }

else {

printf("Ho generato il processo figlio con pid %d\n",pid);

/* pid != 0, sono nel padre */

...

printf{"Attendo la terminazione del figlio con pid %d\n",pid) my_pid = waitpid(pid, &status, 1);

printf{"E’ terminato il processo %d con esito %d\n",my_pid, status/256);

} }

H[HF

6RVWLWXLVFHLOFRGLFHGHOSURFHVVRFRUUHQWHFRQ

LOFRGLFHGHOSURJUDPPDVSHFLILFDWR

PDQWLHQHORVWHVVRSLG

SDVVDLSDUDPHWULDOSURFHVVRFRQLOQXRYR

FRGLFHDWWUDYHUVRODOLQHDGLFRPDQGRDUJFH

DUJY YHGLDSSHQGLFH

HVLVWRQRQXPHURVLYDULDQWLFRQVLGHUHUHPROD

IXQ]LRQHH[HFO

6LQWDVVLGLH[HFO

6LQWDVVL

LQWH[HFOFKDU SDWKBSURJUDPPD

FKDU DUJFKDU DUJ«FKDU DUJQ18//

UHVWLWXLVFHLQW

SDWKBSURJUDPPDSDWKFRPSOHWRGHOILOH

DUJDUJ«DUJQSXQWDWRULDVWULQJKHFKHYHUUDQQRSDVVDWH

FRPHSDUDPHWULDOPDLQGHOSURJUDPPD DUJ GHYHHVVHUHLOQRPHGHOSURJUDPPD

O¶XOWLPRHOHPHQWRGHYHHVVHUHXQSXQWDWRUHD18//

LOYDORUHUHVWLWXLWRq

VHO¶RSHUD]LRQHqVWDWDHVHJXLWDFRUUHWWDPHQWH

VHF¶qVWDWRXQHUURUHHO¶RSHUD]LRQHGLVRVWLWX]LRQHGHO

FRGLFHqIDOOLWD

(23)

8WLOL]]RGLH[HFO

#include <stdio.h>

#include <unistd.h>

void main(int argc, char * argv[]) {

int retstatus;

char par0[] = “my_main1”;

char par1[] = “primo parametro”;

char par2[] = “secondo parametro”;

retstatus = execl(“/usr/home/pozzi/main1", par0, par1, par2, NULL);

}

if (s_pid == 0) {

compito del figlio;

exec(“my_prog”,…)}

else {w_pid = wait(&stato);}

seguito del padre;

Process ID = a

if (s_pid == 0) {...}

il padre attende la terminazione del figlio

};

padre

if (s_pid == 0) {...}

dopo la terminazione del figlio il padre procede l’esecuzione };

Dopo la terminazione di my_prog

main(int argc, char **argv) {

exit(0);

}

figlio (con exec sostituisco il codice)

Termine del processo figlio if (s_pid == 0) {

compito del figlio exec(“my_prog,…”);}

else {};

figlio

H[LW

3RQHWHUPLQHDOSURFHVVRFRUUHQWHILJOLR UHVWLWXHQGRXQFRGLFHDOSURFHVVRSDGUH

6HLOSURFHVVRFKHqWHUPLQDWRQRQKDXQ

SURFHVVRSDGUHLOFRGLFHGHOODH[LWYLHQH

UHVWLWXLWRDOO¶LQWHUSUHWHFRPDQGL

6LQWDVVLGLH[LW

6LQWDVVL

YRLGH[LWLQWVWDWXV

QRQUHVWLWXLVFHQXOODDO

SURFHVVRFKHHVHJXHODH[LW LOSURFHVVRSDGUHSXzDFFHGHUHDOFRGLFHGL

WHUPLQD]LRQHGHOILJOLR

(24)

8WLOL]]RGLH[LW

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

void main(int argc, char * argv[]) { pid_t pid;

int status,retstatus;

pid = fork();

if (pid==0) {

/* il figlio restituisce al padre lo stato di terminazione */

retstatus = 250;

exit(retstatus);}

else { /* pid != 0, sono nel padre */

pid = wait(&status);

printf("E’ terminato il processo %d con esito

%d\n”,pid,status/256);

/* stampera’ il numero del pid del figlio e il numero 250 */

} }

/DSURJUDPPD]LRQHGLUHWH LQDPELHQWHPXOWLSURFHVVR

,OSDUDOOHOLVPRQHLVHUYHU

1HFHVVLWjGLSDUDOOHOLVPR QHLVHUYHU

6HUYHUVHTXHQ]LDOL

 DFFHWWDQRXQDVROD FRQQHVVLRQHDOODYROWD

QRQVRQRSHUWDQWRSDUWLFRODUPHQWHXWLOL(¶

VRORXQDFRPXQLFD]LRQHWUDGXHSURFHVVL

SHUYROWDHYHQWXDOPHQWHDFFRGDQGRDOWUL

SURFHVVLFKHYRJOLDQRFRQQHWWHUVLDOOR

VWHVVRVHUYHUOLVWHQ

VRQRDQFKHGHWWLPRQRFRQQHVVLRQH

1HFHVVLWjGLSDUDOOHOLVPR QHLVHUYHU

6HUYHUSDUDOOHOL

VXSHUDQRLOLPLWLGHLVHUYHUVHTXHQ]LDOL

VIUXWWDQGRLOPHFFDQLVPRGLSDUDOOHOLVPR

XWLOL]]HUHPRLOSDUDOOHOLVPRGL8QL[

WUDVFXUDQGRTXHOORGL:LQGRZV

LOFOLHQWQRQKDPRGRGLGLVWLQJXHUHVHVLq

FRQQHVVRDGXQVHUYHUVHTXHQ]LDOHRDGXQ

VHUYHUSDUDOOHORSXzVRORDFFRUJHUVLGLXQD

FRQQHVVLRQHULILXWDWD

(25)

)XQ]LRQDPHQWR GLXQVHUYHUSDUDOOHOR

,OVHUYHUVLSRQHLQDWWHVDGLULFKLHVWHGL

FRQQHVVLRQLDFFHSWVXXQSRUWVUYSRUW

DOODULFH]LRQHGLXQDULFKLHVWDGL

FRQQHVVLRQHFRQQHFW GHOFOLHQWVX

VUYSRUWLOVHUYHUFUHDWUDPLWHODIRUN XQ

QXRYRSURFHVVRGHWWRILJOLRLGHQWLFRD

VHVWHVVRSURFHVVRSDGUHLPSURSULD

PHQWHGHWWRDQFKHVHUYHUSULQFLSDOH

$OO¶LQWHUQRGHOVHUYHUSDUDOOHOR

'RSRODFUHD]LRQHGHOSURFHVVRILJOLRLO

SDGUHFKLXGHODFRQQHVVLRQHFROFOLHQWH

ULPDQHLQDWWHVDGLQXRYHULFKLHVWHGL

FRQQHFWFKHXWLOL]]HUDQQRVHPSUHOR

VWHVVRVUYSRUW

,OILJOLRXWLOL]]DLOVRFNHWDSHUWRGDO

SDGUHDOODFRQQHFW$OWHUPLQHLOILJOLR

FKLXGHODFRQQHVVLRQHFORVHHWHUPLQD

H[LW

)XQ]LRQDPHQWRGLEDVH GLXQVHUYHUSDUDOOHOR

while (1) /* il server è in un ciclo perenne */

{

new_sd = accept(sd, ...) pid = fork();

if (pid==0) /*sono nel figlio */

{ /*esegui le richieste del client utilizzando il socket connesso new_sd; alla fine chiudi new_sd ed esegui exit */

}

else /* sono nel padre */

{ /*chiudi new_sd e

riprendi ad eseguire la accept su sd */

} }

5HDOL]]D]LRQH

GLXQVHUYHUSDUDOOHOR

0RGLILFDUH6HUYHUFRVuGDUHQGHUORXQ

VHUYHUSDUDOOHOR6HUYHUSDU

QEVXLFDOFRODWRUL8QL[LOWLSRSLGBWFRLQFLGHFRQLOWLSR

LQW9HUUjTXLQGLXWLOL]]DWDODGLFKLDUD]LRQHGHOWLSR

int p_id;

(26)

/LVWDWRGL6HUYHU3DU L

/* programma Server3Par */

#include <stdio.h>

#include <sys/socket.h>

#include <netinet/in.h>

#define PORT 4000

#define MAXCONN 5

void addr_initialize();

void main(int argc, char * argv[])

{ int sd,new_sd,bind_result,listen_result; int pid; char inbuf;

struct sockaddr_in server_addr;

struct sockaddr_in client_addr;

int client_len=sizeof(client_addr);

char rispostaA[]="**il Server ha eseguito il comando A**";

char rispostaB[]="**il Server ha eseguito il comando B**";

char errmessage[]="**comando errato**";

char terminatore[2]={’*’,’\n’};

/LVWDWRGL6HUYHU3DULL

addr_initialize(&server_addr, PORT, INADDR_ANY);

sd=socket(AF_INET,SOCK_STREAM,0);

bind_result=bind(sd,(struct sockaddr*) &server_addr,sizeof(server_addr));

listen_result=listen(sd,MAXCONN);

while (1) {

printf("\nMi pongo in attesa di richieste di connessione\n");

new_sd=accept(sd,(struct sockaddr*) &client_addr,

&client_len);

printf("Ho accettato una connessione da: %d\n", ntohs(client_addr.sin_port));

pid=fork();

/LVWDWRGL6HUYHU3DULLL

if (pid==0){

do{ recv(new_sd,&inbuf,1,0);

printf("Ho ricevuto il comando %c ",inbuf);

printf("da: %d \n", ntohs(client_addr.sin_port));

switch (inbuf) { case ’e’:break;

case ’a’:{send(new_sd,rispostaA, sizeof(rispostaA),0);

send(new_sd,terminatore,2,0);break;}

case ’b’:{printf("i parametri sono: ");

do{recv(new_sd,&inbuf,1,0);

printf("%c",inbuf);

}while (inbuf!=’\0’);

printf(" ");

do {recv(new_sd,&inbuf,1,0);

printf("%c",inbuf);

}while (inbuf!=’\0’);

printf(" \n");

send(new_sd,rispostaB,sizeof(rispostaB),0);

/LVWDWRGL6HUYHU3DULY

default:{send(new_sd,errmessage, sizeof(errmessage),0);

}

} while (inbuf!=’e’);

printf("\nChiudo la connessione con: %d\n\n", ntohs(client_addr.sin_port));

close(new_sd);

exit();

} /* chiude if (pid == 0) */

close(new_sd); /* il padre chiude il socket che */

/* viene utilizzato dal figlio */

} /* chiude while (1) */

} /* chiude main */

(27)

(VHFX]LRQHGL6HUYHU3DU

&RQVLGHULDPRRUDXQHVHPSLRGL

HVHFX]LRQHGL6HUYHU3DUFKHDFFHWWD

FRQQHVVLRQLGDGLVWLQWLSURFHVVL

ULVSHWWLYDPHQWH&&H&

&&H&VRQRHVHFX]LRQLGHO

SURJUDPPD&OLHQWR:&OLHQW

&OLHQWQRQKDPRGRGLULFRQRVFHUHVHLO

VHUYHUFXLVLFROOHJDqVHTXHQ]LDOHR

SDUDOOHOR

(VHFX]LRQHGL6HUYHU3DU

,SURFHVVLILJOLGL6HUYHU3DUXWLOL]]DQR

ODVWHVVDVHVVLRQHGLWHUPLQDOHGHO

SURFHVVRSDGUH

,PHVVDJJLGHOSDGUHHGHLILJOLVDUDQQR

DOWHUQDWLVXXQDXQLFDILQHVWUD

$YYLRGL6HUYHU3DU

&HVHJXHLOFRPDQGRD

(28)

$YYLRGL&

&HVHJXHLFRPDQGLDHE

&HVHJXHLOFRPDQGR[

&HVHJXHLOFRPDQGR\

(29)

$YYLRGL&

&HVHJXHLOFRPDQGRD

&FKLXGHODFRQQHVVLRQH

&HVHJXHLOFRPDQGRE

(30)

&HVHJXHLOFRPDQGR

&FKLXGHODFRQQHVVLRQH

,QYRFD]LRQHGLSURJUDPPL GLVHUYL]LR

8QVHUYHUSUHVHQWDXQ¶LQWHUIDFFLDDWWUDYHUVR

FXLGLIIHUHQWLFOLHQWULFKLHGRQRDTXHOVHUYHU

O¶HVHFX]LRQHGLSURJUDPPLJLjHVLVWHQWL

,OVHUYHUSDUDOOHORIRUN HJHQHUD]LRQHGL

ILJOLRSHURJQLFRQQHVVLRQHULFHYXWDGHYH

HVHJXLUHLOSURJUDPPDVSHFLILFDWRGDOFOLHQW

WUDPLWHXQDH[HF SDVVDQGRJOLLOGHVFULWWRUHGHO

VRFNHW

DWWHQGHUHLOWHUPLQHGHOSURJUDPPDZDLW

(31)

6HUYHU([HF

5LVSHWWRD6HUYHU3DU

qVHPSUHPXOWLSURFHVVRTXLQGLSHURJQL

FRQQHVVLRQHHVHJXHXQDIRUN

DGRJQLULFKLHVWDGDOFOLHQWJHQHUDXQ

XOWHULRUHSURFHVVRWUDPLWHXQDIRUNFKH

HVHJXHLOFRPDQGRLQGLFDWRGDOFOLHQW

WUDPLWHODH[HFO

SDVVDDOSURJUDPPDLQYRFDWR0DLQ$R

0DLQ%LOGHVFULWWRUHGHOVRFNHWSHU

FRPXQLFDUHFROFOLHQW

/LVWDWRGL6HUYHU([HFL

/* programma Server3Exec */

#include <stdio.h>

#include <sys/socket.h>

#include <netinet/in.h>

#define PORT 4000

#define MAXCONN 5

void addr_initialize();

int sd,new_sd,bind_result,listen_result; char inbuf;

struct sockaddr_in server_addr;

struct sockaddr_in client_addr;

int client_len=sizeof(client_addr);

char errmessage[]="**comando errato**"; /* rispetto a Server3Pa mancano */

char terminatore[2]={’*’,’\n’}; /* rispostaA e rispostaB */

char sdstring[7]; /* nuovo rispetto a Server3Par */

int pid,my_pid,status;

/LVWDWRGL6HUYHU([HFLL

addr_initialize(&server_addr, PORT, INADDR_ANY);

sd=socket(AF_INET,SOCK_STREAM,0);

bind_result=bind(sd,(struct sockaddr*) &server_addr,sizeof(server_addr));

listen_result=listen(sd,MAXCONN);

while (1) {

printf("\nMi pongo in attesa di richieste di connessione\n");

new_sd=accept(sd,(struct sockaddr*) &client_addr, &client_len);

printf("Ho accettato una connessione da: %d\n", ntohs(client_addr.sin_port));

pid=fork();

if (pid==0) { do

{

recv(new_sd,&inbuf,1,0);

printf("Ho ricevuto il comando %c ",inbuf);

printf("da: %d \n", ntohs(client_addr.sin_port));

/LVWDWRGL6HUYHU([HFLLL

switch (inbuf) {

case ’e’:break;

case ’a’:{sprintf(sdstring,"%d",new_sd);

pid=fork();

if (pid==0) {

execlp(“./MainA", “MainA”, sdstring, NULL);

printf(“errore di execl”); exit(255)}

else {my_pid = wait(&status); break;}}

case 'b':{sprintf(sdstring,"%d",new_sd);

pid=fork();

if (pid==0) {

execlp(“./MainB", “MainB”, sdstring, NULL);

printf(“errore di execl”); exit(255)}

else {my_pid = wait(&status); break;}}

default: {send(new_sd,errmessage, sizeof(errmessage),0);

} /* chiude switch */

} while (inbuf!='e'); /* chiude do */

(32)

/LVWDWRGL6HUYHU([HFLY

printf("\nChiudo la connessione con: %d\n\n", ntohs(client_addr.sin_port));

close(new_sd);

exit();

} /* chiude if (pid == 0) */

close(new_sd); /* il padre chiude il socket che */

/* viene utilizzato dal figlio */

} /* chiude while (1) */

} /* chiude main */

/LVWDWRGL0DLQ$

/* programma MainA */

int sd;

char terminatore[2] = {’*’,’\n’};

char rispostaA[] = "**MainA ha eseguito il comando A**";

printf(" MainA\n");

sd = atoi(argv[1]);

send(sd, rispostaA, sizeof(rispostaA),0);

send(sd, terminatore,2,0);

printf(" MainA: ho terminato\n");

exit(0);

}

&RPXQLFD]LRQH&OLHQW0DLQ%

/DFRPXQLFD]LRQHWUD&OLHQWH0DLQ%

DYYLHQHDWWUDYHUVRLOGHVFULWWRUHGHO

VRFNHW

&OLHQWQRQVLDFFRUJHGLSDUODUHFRQ

0DLQ%qFRQYLQWRGLSDUODUHFRQ

6HUYHU([HF

0DLQ%ULFHYHVXOODOLQHDGLFRPDQGRLO

GHVFULWWRUHGHOVRFNHWSHUFROORTXLDUH

FRQ&OLHQW

/LVWDWRGL0DLQ%

/* programma MainB*/

void main(int argc, char * argv[]) { int sd; char inbuf;

char rispostaB[] = "**MainB ha eseguito il comando B**";

char terminatore[2] = {’*’,’\n’};

sd = atoi(argv[1]);

printf(" MainB: i parametri sono:");

do { recv(sd, &inbuf, 1, 0);

printf("%c", inbuf);

} while (inbuf != ’\0’);

prinf(" ");

do { recv(sd, &inbuf, 1, 0);

printf("%c",inbuf);

} while (inbuf != ’\0’);

printf("\n" );

send(sd, rispostaB, sizeof(rispostaB),0);

send(sd, terminatore, 2, 0);

printf(" MainB: ho terminato\n");

exit(0);

}

(33)

$YYLRGL6HUYHU([HF

&OLHQWULFKLHGHLOFRPDQGRH

ORLQYLDDOVHUYHU

6HUYHU([HFULFHYH

LOFRPDQGREHODQFLDO¶HVFX]LRQH

GL0DLQ%

&OLHQWULFHYHLPHVVDJJL

GD0DLQ%

(34)

proc. Aproc. B proc. Dproc. C

/D3URJUDPPD]LRQH GL5HWHHGL6LVWHPD LLL

/DSURJUDPPD]LRQHGLVLVWHPD

,QWURGX]LRQHDOVLVWHPDRSHUDWLYR HGLOVLVWHPDRSHUDWLYRPXOWLSURFHVVR

,OVLVWHPDRSHUDWLYR

 ,OVLVWHPDRSHUDWLYR

,OVLVWHPDRSHUDWLYR

,OSURFHVVRGDOSXQWRGLYLVWD

GHOVLVWHPDRSHUDWLYR

 ,OSURFHVVR q

/RVWDWRGLXQSURFHVVR

,OVLVWHPDRSHUDWLYRHOH

PDFFKLQHYLUWXDOL

 ,OVLVWHPDRSHUDWLYR

,OVLVWHPDRSHUDWLYR

,OVLVWHPDRSHUDWLYRHOH

PDFFKLQHYLUWXDOL

,OVLVWHPDRSHUDWLYR HOHPDFFKLQHYLUWXDOL

,OVLVWHPDRSHUDWLYR HODPDFFKLQDUHDOH

,OVLVWHPDRSHUDWLYR

 ,OVLVWHPDRSHUDWLYR

,SURFHVVLHGLOVLVWHPD

RSHUDWLYR

 $QFKHLOVLVWHPDRSHUDWLYRq

LPSOHPHQWDWRWUDPLWHSURFHVVL

 LOVLVWHPDRSHUDWLYRqJDUDQWHFKHL

FRQIOLWWLWUDLSURFHVVLVLDQRFRQWUROODWLH

JHVWLWLFRUUHWWDPHQWH

 LOVLVWHPDRSHUDWLYRYLHQHHVHJXLWRLQ

PRGDOLWjSULYLOHJLDWD NHUQHOPRGH R

VXSHUYLVRU FRVuGDSRWHUFRQWUROODUHJOL

DOWULSURFHVVLHVHJXLWLLQPRGDOLWjXVHU

&KLDPDWHDOVXSHUYLVRU

 ,SURFHVVLXWHQWHSHUHVHJXLUH

RSHUD]LRQLSULYLOHJLDWHFRPHDGHV

LQYRFDQRLOVXSHUYLVRU WUDPLWHFKLDPDWH

GLVLVWHPD V\VWHPFDOOV 

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

 /HRSHUD]LRQLGL,2VRQRRSHUD]LRQL

ULVHUYDWH

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

 8QSURFHVVRQRQGHYHSRWHUVFRQILQDUH

DOGLIXRULGHOSURSULRVSD]LRGL

PHPRULD

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

 /DFRQGLYLVLRQHGLULVRUVHTXDOLDG

HVHPSLRGLVFKL&38VFKHGHGLUHWH

0RWLYD]LRQLGHOO¶XVR GHOVXSHUYLVRU

 (VVHQGRXQVLVWHPDPXOWLSURJUDPPDWR

HRPXOWLXWHQWH

1HFHVVLWjGLSDUDOOHOLVPR QHLVLVWHPLRSHUDWLYL

 8QXWHQWHFKHVLFROOHJDDGXQD

PDFFKLQD DGHV8QL[WUDPLWHLO

SURJUDPPDWHOQHW GLVSRQHGLXQ

LQWHUSUHWHFRPDQGLHYHQWXDOPHQWH

VFHOWRGDOO¶XWHQWHVWHVVRWUDPLWHFKVK

 1HOODPDFFKLQDGHYHHVVHUHSUHVHQWHXQ

SURFHVVRLQWHUSUHWHFRPDQGLSHURJQL

VHVVLRQH

1HFHVVLWjGLSDUDOOHOLVPR QHLVLVWHPLRSHUDWLYL

 $GRJQLQXRYDFRQQHVVLRQHLOVLVWHPD

RSHUDWLYRJHQHUDXQSURFHVVRLQWHUSUHWH

FRPDQGLVSHFLILFRSHUTXHOOD

FRQQHVVLRQH

 &LVRQRTXLQGLSLFRSLHGHOORVWHVVR

SURJUDPPD

3DUDOOHOLVPRLQ8QL[

 (VLVWRQRGXHSULQFLSDOLPHWRGLSHU

RWWHQHUHO¶HVHFX]LRQHSDUDOOHODLQ

DPELHQWH8QL[

 &RQVLGHUHUHPRODJHQHUD]LRQHGLQXRYL

SURFHVVL PHFFDQLVPRSLVWDQGDUGH

PHQRFRPSOHVVR 

/DSURJUDPPD]LRQHGLVLVWHPD

'HILQL]LRQL

'HILQL]LRQH

 &RQSURJUDPPD]LRQHGLVLVWHPD VL

LQWHQGRQROHWHFQLFKHXWLOL]]DWHQHOOD

VFULWWXUDGLSURJUDPPLXWHQWH FLRqQRQ

QHFHVVDULDPHQWHHVHJXLWLLQPRGDOLWj

/D3URJUDPPD]LRQH GL5HWHHGL6LVWHPDLLL

,OVLVWHPDRSHUDWLYR

,OSURFHVVR q

,OVLVWHPDRSHUDWLYR

,OVLVWHPDRSHUDWLYR

$QFKHLOVLVWHPDRSHUDWLYRq

LPSOHPHQWDWRWUDPLWHSURFHVVL

LOVLVWHPDRSHUDWLYRqJDUDQWHFKHL

JHVWLWLFRUUHWWDPHQWH

LOVLVWHPDRSHUDWLYRYLHQHHVHJXLWRLQ

PRGDOLWjSULYLOHJLDWDNHUQHOPRGH R

VXSHUYLVRUFRVuGDSRWHUFRQWUROODUHJOL

DOWULSURFHVVLHVHJXLWLLQPRGDOLWjXVHU

,SURFHVVLXWHQWHSHUHVHJXLUH

RSHUD]LRQLSULYLOHJLDWHFRPHDGHV

GLVLVWHPDV\VWHPFDOOV

/HRSHUD]LRQLGL,2VRQRRSHUD]LRQL

ULVHUYDWH

8QSURFHVVRQRQGHYHSRWHUVFRQILQDUH

PHPRULD

/DFRQGLYLVLRQHGLULVRUVHTXDOLDG

HVHPSLRGLVFKL&38VFKHGHGLUHWH

(VVHQGRXQVLVWHPDPXOWLSURJUDPPDWR

HRPXOWLXWHQWH

8QXWHQWHFKHVLFROOHJDDGXQD

PDFFKLQDDGHV8QL[WUDPLWHLO

SURJUDPPDWHOQHWGLVSRQHGLXQ

LQWHUSUHWHFRPDQGLHYHQWXDOPHQWH

VFHOWRGDOO¶XWHQWHVWHVVRWUDPLWHFKVK

1HOODPDFFKLQDGHYHHVVHUHSUHVHQWHXQ

VHVVLRQH

$GRJQLQXRYDFRQQHVVLRQHLOVLVWHPD

FRQQHVVLRQH

&LVRQRTXLQGLSLFRSLHGHOORVWHVVR

SURJUDPPD

(VLVWRQRGXHSULQFLSDOLPHWRGLSHU

DPELHQWH8QL[

&RQVLGHUHUHPRODJHQHUD]LRQHGLQXRYL

SURFHVVLPHFFDQLVPRSLVWDQGDUGH

PHQRFRPSOHVVR

&RQSURJUDPPD]LRQHGLVLVWHPD VL

VFULWWXUDGLSURJUDPPLXWHQWHFLRqQRQ

VXSHUYLVRUFKHLQWHUDJLVFRQR

FKHXWLOL]]DQRLVHUYL]LV\VWHPFDOOV PHVVLDGLVSRVL]LRQHGDTXHVW¶XOWLPR

/HFKLDPDWHGLVLVWHPDVRQRGLYLVHQHOOH

VHJXHQWLSULQFLSDOLFDWHJRULH

$OO¶LQWHUQRGHOODSURJUDPPD]LRQHGL

VLVWHPDODQRVWUDDWWHQ]LRQHVL

&SHU

/HSULQFLSDOLRSHUD]LRQLGLDFFHVVRDILOH

FRQVHQWRQRGL

/HSULQFLSDOLRSHUD]LRQLVXLSURFHVVL

FRQVHQWRQRGL

(¶XQFRQWHQLWRUHGLLQIRUPD]LRQL

(¶DQFKHGHWWR³ORQJOLYHGREMHFW´

(¶LGHQWLILFDWRGD

8QSURJUDPPDDGHVLQ&FKHGHVLGHUD

VWUHDPGLFRPXQLFD]LRQHLQYRFDQGRLO

VLVWHPDRSHUDWLYR

,OVLVWHPDRSHUDWLYRUHVWLWXLVFHDOSURJUDPPD

LOGHVFULWWRUHGHOILOH KDQGOHHPHPRUL]]D

VHPSUHODSRVL]LRQHFRUUHQWHQHOILOH

2JQLRSHUD]LRQHVXOILOHDYYLHQHWUDPLWH

KDQGOH$OWHUPLQHLOSURJUDPPDFKLXGHLO

ILOHULODVFLDQGRLOGHVFULWWRUH

9LVRQRWUHIOXVVLVWDQGDUGDVVRFLDWLDG

RJQLSURFHVVR

$WDOLIOXVVLVLDJJLXQJRQRHYHQWXDOLILOH

DSHUWLGDOSURJUDPPD

'LWHVWR $6&,,

%LQDUL ELQDU\

$SHUWXUDIRSHQ DSUHXQILOH

&KLXVXUDIFORVH FKLXGHXQILOH

&DQFHOOD]LRQHUHPRYH SHUFDQFHOODUHXQ

ILOH

5LGHQRPLQD]LRQHUHQDPH PRGLILFDLO

QRPHGLXQILOHRVSRVWDUORGLGLUHWWRULR

%LQDULR

/HWWXUDHVFULWWXUD

$SHUWXUDGHOILOH