Experimental Study on Time and Space Sharing on the PowerXplorer

Transcription

1 Experimental Study n Time and Space Sharing n the PwerXplrer Sulieman Bani-Ahmad CWRU, Ohi, USA. sulieman@case.edu Ismail Ababneh AABU, Mafraq, Jrdan Ismail@aabu.edu.j ABSTRACT Scheduling algrithms in parallel cmputers fall int tw basic categries: time and space sharing algrithms. Space-sharing based prcessr allcatin algrithms can be cntiguus r nn-cntiguus. Studies shw that nn-cntiguus allcatin is superir due t decrease in fragmentatin. Other studies have reprted that executing jbs n fewer prcessrs (flding) can imprve the perfrmance f cntiguus and nn-cntiguus allcatin. Hwever, the prblem with flding is that it is nt always applicable because f parallel prgramming languages and parallel perating systems limitatins. Mst f previus studies used simulatin. Our study is an experimental ne fr studying time and space sharing n a real parallel machine (the PwerXplrer), with eight prcessrs arranged as a tw-dimensinal mesh. A set f five scientific applicatins with differing cmmunicatin characteristics were implemented and executed using time and space sharing. The bserved executin times were used t study and cmpare time-sharing and cntiguus and nn-cntiguus space sharing with and withut flding. Our study shwed that time-sharing gave cmparable results t space sharing allcatin. Further, nn-cntiguus allcatin gave better results than cntiguus allcatin when flding is nt supprted. Hwever, when flding is supprted cntiguus allcatin gave the best mean turnarund times. Keywrds: Scheduling algrithms, parallel prgrammin, parallel cmputing. 1 INTRODUCTION A jb in multiprgrammed parallel systems is characterized alng tw dimensins; the length, measured by the executin time and the width r size measured by the number f threads such that each thread is executed n a separate prcessr. Thus, resurce sharing in parallel cmputers takes tw levels, (i) time sharing, whereby a thread can be interrupted during executin by ther threads f jbs running n the same prcessr, (ii) space sharing, where a thread has exclusive use f its prcessr until its executin is cmplete [11]. Space sharing can be cntiguus r nn-cntiguus depending n whether the prcessrs allcated t a single jb are physically adjacent r nt [13]. Cmparisn studies shw that nn-cntiguus allcatin is superir t cntiguus allcatin as the frmer prduces less external fragmentatin [13]. Hwever, cntiguus allcatin is preferred as it prvides maximum cmmunicatin speed between threads f the same jb [13]. Flding, that is executing jbs n fewer prcessrs, can imprve perfrmance f cntiguus and nncntiguus allcatin [12]. The prblem with flding is that it is nt always applicable due t limitatins f parallel prgramming languages and parallel perating systems [12]. Mst previus studies used simulatin t study and cmpare different scheduling prcessr allcatin strategies. This study, hwever, is an experimental ne fr studying time and space sharing n a real parallel machine (the PwerXplrer) with eight prcessrs arranged in a tw dimensinal mesh and uses PARIX perating system and parallel prgramming language. This study passed by the fllwing stages: (i) We selected a set f five scientific applicatins t implement and later use t cmparatively assist different allcatin strategies. Tw f these applicatins, namely Matrix multiplicatin (MM) and LU factrizatin, are used in well-knwn parallel benchmarks like NAS [3] and GENESIS [2]. The ther applicatins are (a) 2D Fast Furier Transfrm (2D FFT), which is used in image prcessing, (b) Flyd shrtest path algrithm frm graph thery, and (c) a simulatin f electrmagnetic wave prpagatin in 2D space using Finite-difference in time dmain (FDTD) frm Electrmagnetics. (ii) We implemented the selected applicatins in PARIX envirnment. The applicatins were run n the PwerXplrer using time sharing (TS) and bth cntiguus and nn-cntiguus space sharing (CSS, NCSS). (iii) The executin times are used as inputs t a simulatr t study and cmparatively evaluate cntiguus and nn-cntiguus space sharing (a) with and withut flding, and (b) with bunded Vlume 3 Number 1 Page 46

2 flding, which limits flding factr. The flding factr fr a particular jb j that requests n j is defined as the rati between the number actually allcated t j and n j. The main cntributin f this paper is that it cmparatively assists time sharing and different prcessr strategies n a real parallel cmputer, namely the PwerXplrer. Our majr findings are: TS gave clse average executin times t CSS and smetimes perfrmed better with large allcatin sizes, i.e. when relatively large allcatin sizes. Further, literature shws that TS (i) reduces the jb s wait time (befre allcatin), (ii) dampens the effect f idle state f prcessrs that ccurs when a thread halts waiting fr cmmunicatin r I/O peratins. Therefre, TS can be useful t interactive parallel cmputer systems that require lw respnse times t user cmmands. Simulatin shws that nn-cntiguus allcatin acheives better results than cntiguus allcatin when flding is nt supprted. Hwever, when flding is supprted, cntiguus allcatin gives the best mean turnarund times. The remainder f this paper is rganized as fllws: Sectin 2 presents the PwerXplrer and PARIX perating system and prgramming language. The studied prcessr allcatin strategies are briefly described in sectin 3. Sectin 4 presents the implementatin details f the five scientific applicatins used in the experimental part f this study. The simulatin details are described in sectin 5. In sectin 6, we present ur main experimental results and bservatins. Sectin 7 prvides ur cnclusins. 2 The PwerXplrer and PARIX The PwerXPlrer is a family f distributed memry systems frm Parsytec ( This system runs the PARIX perating system and is based n 8 prcessing units arranged in a 2D mesh, as illustrated in figure 1. Each prcessing unit has (i) ne 80-MHz PwerPC 601 prcessr, (ii) 8 MB f lcal memry and (iii) a transputer fr establishing and maintaining Figure 1: The 2D mesh f cmmunicatin links the PwerXplrer with prcessr IDs. PARIX (PARallel UnIX extensins) [7] is the native perating system in the Parsytec PwerXplrer family. It prvides UNIX functinality at the frnt-end with library extensins fr the needs f the parallel system. The Parix sftware package cmprises cmpnents fr the prgram develpment envirnment (cmpilers, tls, etc.) and runtime envirnment (libraries). PARIX ffers different types f synchrnus and asynchrnus cmmunicatin [7]. 3. Studied Scheduling Strategies Besides time sharing, we study the perfrmance f the fllwing prcessrs allcatin strategies f space sharing. (i) Space sharing withut flding: We test tw strategies under this categry, namely, Cntiguus Space Sharing (CSS) and Nn-Cntiguus Space Sharing (NCSS). In general, a CSS strategy starts by allcating the exact requested number f prcessrs. If it fails, the requesting jb waits until enugh idle prcessrs becme available. In NCSS hwever, if allcating a cntiguus set fails, the algrithm lks fr a nn-cntiguus set. If it fails again, the requesting jb waits until the needed number f prcessrs becmes available. (ii) Space sharing with flding: Flding is allcating a fewer number f prcessrs than requested in case nt enugh idle prcessrs are fund. We test fur strategies under this categry: (a) Cntiguus space sharing with unbunded flding (CSSUF), which puts n limits n the flding factr. We define the flding factr as the rati between the requested number f prcessrs and the actual nember allcated after flding. This strategy puts n limits n the flding factr, i.e. it may fld any jb requesting n i prcessrs t ne prcessr with flding factr 1/n i. (b) Nn-cntiguus space sharing with unbunded flding, which differs frm the previus ne in that it relaxes the cntiguity cnditin and tries t allcate a nn-cntiguus set f prcessrs if a cntiguus set is nt available befre flding. (c) Cntiguus/nn-cntiguus space sharing with bunded flding (CSSBF, NCSSBF), which are similar t the previus tw except in that they allw maximum flding factrs f k/n i where n i is the requested number f prcessrs and k is the minimum number f prcessrs that can be allcated t any jb. We chse k=2 as we have relatively small mesh (8 prcessrs). Fr example, we allwed flding factrs f 1/4, 1/3 and ½ and 1 n the requests fr 8, 6, 4 and 2 prcessrs respectively. 4. Implementatin Details f the Selected Applicatins T facilitate parallelizing the five scientific applicatins, we chse the size f the input t be dividable by 1, 2, 4, 6 and 8. Further, at run time, ne f the instantiated threads f the applicatin, arbitrarily selected, takes divides the data input Vlume 3 Number 1 Page 47

3 between all ther threads. The same thread is respnsible fr gathering the final results. We refer t this thread as the main thread. Figure 3 shws the main lps f Matrix Multiplicatin. M a and M b are the input matrices t be multiplied and M c is the result matrix. The matrices are f size 384*384 each. The algrithm is parallelized by dividing the rws f M a and the clumns f M b int n slices each, where n is the number f prcessrs assigned t the applicatin (1, 2, 4, 6 r 8). A ttal f n threads are instantiated at each prcessr. The main thread distributes the slices such that each thread initially receives a slice f M a and anther f M b (One-t-All cmmunicatin). The threads, in turn, start t cmpute the M c slice assigned t them. During cmputatin, All-t-All cmmunicatin ccurs between the threads as fllws; thread f ID j (i) passes the M b slice that it has t its neighbr with ID j+1 and (ii) receives its j-1 s M b slice and (iii) cmputes the crrespnding prtin f the M c slice. The three steps mentined abve, (i), (ii) and (iii) are repeated n-1 times. Finally, the main thread cllects back M c slices (All-t-One cmmunicatin). As it is quicker than asynchrnus cmmunicatin, we use Synchrnus Cmmunicatin in all applicatins, i.e. the tw cmmunicating threads shuld be at bth sides f the cmmunicatin channel simultaneusly. T prevent deadlck due t cmmunicatin, the threads with dd IDs start sending first and simultaneusly the threads with even IDs receive. Next, the rles are reversed. Figure 2 shws the main lps f Flyd s shrtest path algrithm. V is the number f vertices in the input graph G(V,E), where V and E are the vertex and edge lists. We chse V =384. M initially is the edge-weight matrix f G. After Flyd s algrithm is applied n G, M becmes the shrtest matrix. At each iteratin f lp k (figure 2), the distances between the vertices scanned by lps i and j, M[i][j], are updated as fllws: if the distance between vertices i and j passing by k is shrter than the current distance between i and j, then the entry M[i][j] is updated t the new shrter distance. fr(k=0;k< V ;k++) fr(i=0;i< V ;i++) fr(j=0;j< V ;j++) {if(m[i][j] > (M[i][k]+M[k][j])) M[i][j] = M[i][k]+M[k][j];} Figure 2: The main lps f Flyd s algrithm fr(i=0;i<md;i++) fr(j=0;j<md;j++) fr(k=0;k<md;k++) Mc[i][j]+=Ma[i][k]*Mb[k][j]; Figure 3: The main lps f Matrix Multiplicatin prcedure Flyd s algrithm is parallelized by instantiating n threads. The rws f M are divided int n slices. The main thread passes each slice t its crrespnding thread (One-t-All cmmunicatin). During shrtest-path cmputatin, the thread that has the k th rw (figure 2) passes it t all ther threads (All-t-All cmmunicatin). The main thread gathers the updated slices f M (All-t-One cmmunicatin). Figure 4 shws the main lps f LU factrizatin applicatin based n Gaussian eliminatin. Where dim is the size f the matrix (M lu ) t be factrized. After the eliminatin is perfrmed, M lu, will have bth the L matrix (the values belw the diagnal) and the U matrix (the values abve the diagnal). The applicatin is parallelized by dividing M lu s fr (k=0;k<dim-1;k++) { fr (i=k+1;i<dim;i++) { factr=m lu [i][k]/m lu [k][k]; M lu [i][k]=factr; fr (j=k+1;j<dim;j++) {M lu[i][j]=m lu[i][j]-factr*m lu[k][j];} } } Figure 4: The main lps f LU factrizatin cde. clumns int n slices, where n is the number f prcessrs. The main thread distributes the slices and at the end cllects it back (One-t-All and Allt-One cmmunicatin). Depending n k (figure 4), the thread that determines the eliminatin factr sends the factr t all threads f interest t perfrm eliminatin (the threads that have any rw belw the k th rw). The 2D FFT is similar t the well-knwn 1D FFT accept that the frmer is perfrmed n matrices instead f vectrs. The 2D FFT is perfrmed n a matrix M by implementing 1D FFT n the rws f M t prduce M, and then n the clumns f M. The dimensin f the vectrs shuld be f the pwer f tw. Thus we chse M t be f size 1024*1024 in ur experiments. Parallelizing 2D FFT is cnducted as fllws; the rws f M are divided int n slices, where n is the number f prcessrs allcated fr the 2D FFT jb. Each slice is f size 1024/n*1024. The main thread distributes the slices between all ther threads. Having dne that, the tw stages f 2D FFT are perfrmed as fllws: (i) Each thread perfrms 1D FFT n the rws f the slice it has. Having dne that, each thread further slices the clumns f the result 1024/n*1024 matrix int n slices. The new slices are exchanged between the threads s that each thread receives a clumn slice f the cmplete transfrmed matrix f this stage, i.e. M. (ii) Again, 1D FFT is perfrmed n the clumnslices. At the end, the main thread cllects back the clumn slices f the final transfrmed matrix. Electrmagnetic wave prpagatin simulatin in space is dne by iteratively cmputing tw Vlume 3 Number 1 Page 48

4 cmpnents, namely, the electric filed and the magnetic filed cmpnents accrding t the fur equatins shwn in figure 5. We chse t simulate electrmagnetic wave prpagatin in 2D space as described in [5]. D 1 z = H y H x, D (ω ) = ε * (ω ).E (ω ) where T nc (A, n ) / T c (A, n ) are the executin times f applicatin A n n nn-cntiguus/cntiguus prcessrs respectively. We experimentally fund that nc2ctr = 1.1. Jbs are served in First In First Out (FIFO) rder. The cntiguus allcatin strategies used is the First Fit as described in [8]. Jb sizes are chsen z r z t ε μ x y unifrmly randm frm the set {1, 2, 4, 6, 8}. We H 1 E x = t ε μ y H y = 1 E z t ε μ x Figure 5: The fur cmpnents f the electrmagnetic field. μ is the free space permeability f the magnetic field. ε is the z als cnsidered anther distributin that favrs small-size jbs. Hwever, the bservatins f bth were the same, thus we nly reprt the case f unifrmly distributed jb sizes. The utputs f the simulatrs are: (i) The Average System Utilizatin (ASU), which free space permittivity f the electrical field, H and E are the is defined as ASU = ( SU (t)) / T where T is the 0 magnetic and electric fields respectively. And D is the electric flux density. simulatin time. SU (t ) is the system utilizatin at time t. System utilizatin at any mment is The simulatin is cnducted as fllws: We cmputed as the number f the busy prcessrs initialize the fur matrices D z, E z, H x and H y t divided by the ttal number f prcessrs in the zers. Each entry in the matrix D z represents the electric flux density at the crrespnding pint in system. (ii) The Average Turnarund Time (ATT), which space. Similarly, each entry f the matrices E z, H x N is defined as A TT = ( T T ( j )) / N where TT ( j ) is the and H y represents the electric and magnetic fields cmpnents at the crrespnding pint in the space. A wave pulse surce is placed in the space. After that, we iteratively cmpute the values f the different electrmagnetic field cmpnents. Each iteratin represents a mment f time elapsed. Fr mre details, refer t [5]. The electrmagnetic wave prpagatin is parallelized as fllws: The 2D space t be studied is divided int n smaller subspaces f equal sizes. Each thread f the instantiated n threads is respnsible f updating the fur cmpnents, namely the electric field and the electric flux density, and the tw magnetic field cmpnents. The threads that are respnsible f cntiguus small spaces exchange the values f the fur cmpnents lcated at the bundaries. 5. Simulatin Details After we implemented the five applicatins described in sectin 4 abve, we executed them n varius numbers f prcessrs cnsidering time and space sharing. After that, we used the bserved executin times t further study and experimentally evaluate different prcessr allcatin algrithms with and withut flding n the PwerXplrer. T quantify and simulate the effect f nncntiguity n the executin time f applicatins, we experimentally cmpute the nn-cntiguus t cntiguus time rati, nc2ctr using the frmula j =1 T turnarund time f jb j and N is the ttal number f served jbs. TT ( j ) is cmputed as TT ( j ) = W T ( j ) + ET ( j ) where WT ( j ) and ET ( j ) are the waiting and executin times f jb j, respectively. The abve parameters are measured with a cnfidence interval f 0.95 and a maximum errr level f Experimental Results and Observatins Table 1 shws the executin times f the selected applicatins n 1, 2, 4, 6 and 8 prcessrs. Matrix Flyd FDTD simulatin n T S e T S e T S e LU factrizatin 2D FFT * Pwer f 2 prcessrs is n T S e T S e required fr the FFT parallel algrithm T: executin time S: Speed up * e: Efficiency Table 1: Executin times, speed-up values and efficiency value f the selected applicatins. Prblem Sizes: (MM) 384x385. (Flyd): 480 pints (FDTD): 384x384. (LU): 768*768 (2D FFT): 1024x1024 Observatin: (Table 1) Speed-up and efficiency values in MM and FDTD were high, hwever, they were lw in Flyd, LU factrizatin and 2D FFT. The abve bservatin results frm the differences in the time spent by different applicatins nc 2ctr = Max n {1,2,4,6,8} (T nc (A, n ) /T c (A, n )) perfrming cmmunicatin cmpared t the time A {" MM "," Flyd "," LU "," 2 DFFT "," FDT D "}. they spend n cmputatin. The Speed-up is lw in Vlume 3 Number 1 Page 49

5 the cases where cmmunicatin t cmputatin rati is high [15], as in the case f Flyd s algrithm. The best speedup we btained where in MM and FDTD, where the cmmunicatin cmpared t cmputatin times were lw cmpared t the time spent in cmputatin. T supprt the abve illustratin, we cmpute the cmmunicatin times in the case f MM and Flyd. We use the pint-t-pint cmmunicatin mdel described in [14]. Accrding t this mdel, the time needed t send a message f size s frm ne pint t anther pint ( t (s ) in secnds) is given by t (s ) = t + s / r, where t is the startup r latency time. r is the asympttic bandwidth defined as the maximum achievable bandwidth when message length appraches infinity [14]. The latency time f pint-t-pint cmmunicatin in PARIX n the PwerXplrer is given by t = * p (in micr secnds) [14], where p is the number f prcessrs in the path frm the surce t the destinatin (including the surce and the destinatin pints) [14]. The parameter r is als estimated by 1.05 MB/Sec [14]. Using this mdel and given the data input sizes f the implemented applicatins, ne can estimate the cmmunicatin times as in the next example. Example: In the case f executing the MM applicatin n 4 cntiguus prcessrs as illustrated in figure 6, and given that the input matrix is defined as an array f flats (each flat variable ccupies 4 bytes in memry), we can cmpute the All-t-All cmmunicatin time as fllws: - a ttal f 4*(4-1) messages are sent. - each message is f size s=384/4*384 (flat /message)* 4 (bytes/flat) / 2 10 MBytes. Thus, the cmmunicatin time f the 12 messages Figure 6: 2x4 2D mesh (withut cnsidering the cmmunicatin latencies) is 12 * s / r = 12 * = secnds. - The latency times vary depending n the length f the path. 4 f the 12 messages have a path length f 3. These fur cmmunicatin peratins ccur between MM threads running n prcessrs 0 and 3 (tw peratins) and between the threads running n 1 and 2 (anther tw peratins). The ther 8 peratins are each f length 2. Thus, the ttal latency time needed t send 12 messages is t = 4( * 3) + 8( * 2) = 1167 μs. - Finally, the ttal All-t-All cmmunicatin time is secnds. This frms 6.8% f the ttal executin time f MM n fur cntiguus prcessrs. Repeating same calculatins fr the 2D FFT n fur prcessrs, we ntice that the cmmunicatin time is arund secnds which frms arund 40% f the ttal executin time which is 7.9 secnds. This explains the reasn why efficiency may decrease as the number f prcessrs increases. 6.1 Time Sharing and Serial Executin Runtimes Table 2 shws the bserved executin times n 8 prcessrs f all the applicatins executed serially and using time sharing. Fr instance, t implement time sharing n the eight prcessrs between MM and FDTD, we instantiated tw threads n each prcessr, a thread fr MM and anther fr FDTD. Observatin: (Table 2) Flyd Applicatins TS SE takes 18.7 secnds when singly executed n eight prcessrs. Hwever, when executed using time sharing with MM and LU (that require 7.7 and 23.3 secnds respectively), Flyd s A1 A2 A1 A2 A1 A2 Sum MM MM MM FLOYD MM LU MM FFT MM FDTD FLOYD FLOYD FLOYD LU FLOYD FFT FLOYD FDTD LU LU LU FFT LU FDTD FFT FFT FFT FDTD FDTD FDTD Table 2: The executin times in time sharing and serial executin strategies n eight prcessrs. executin time raises t 25.3 and 31.0 secnds, respectively. The illustratin f the abve bservatin is that applicatins with relatively shrt executin time relinquish its prcessr(s) early. Therefre, they have less effect n the executin time f the ther applicatins running simultaneusly n the same prcessr(s). Observatin: (Table 2) Finish time with time sharing is in average 15.3% less than serial executin. Fr instance, the serial executin time f MM and FDTD was 23.9 secnds. With time sharing hwever the MM applicatin finished after 10.8 secnds and the ther after 21.1 secnds. 2.8 secnds where saved by time-sharing. Time-sharing threads uses the shared prcessr alternatively s.t. when a thread halts waiting fr cmmunicatin the ther ready threads may resume executin, thus, less prcessr clck cycles are wasted. We als bserved that, as the number f prcessrs allcated fr the applicatins being executed in time-sharing manner decreases, the time difference between serial and the time-sharing executin decreases. The reasn is that the time spent in cmmunicatin increases as the number f prcessrs used increases. Thus, the prcessr clck cycles while waiting fr the cmmunicatin prcess t ccur/finish increase, which in turn prvides an pprtunity fr mre cycles t be utilized. Vlume 3 Number 1 Page 50

6 6.2 Cntiguus and Nn-cntiguus Space Sharing Table 3 shws the executin times f tw applicatins sharing the space f eight prcessrs (Cntiguus allcatin). Tw cnfiguratins are presented: (i) the 4, 4 cnfiguratin (Case A), where each applicatin is assigned 4 prcessrs, and (ii) the 2, 6 cnfiguratin (Case B), where ne applicatin is assigned 2 prcessrs and the ther is assigned 6. Applicatins CSS Case A CSS Case B A1 A2 A1: 4 A2: 4 A1: 2 A2: 6 MM MM MM FLOYD MM LU MM FFT MM FDTD FLOYD FLOYD FLOYD LU FLOYD FFT FLOYD FDTD LU LU LU FFT LU FDTD FFT FFT FFT FDTD FDTD FDTD Table 3: Executin times using cntiguus space sharing n eight prcessrs. running n 1 and 2. Assume the fllwing scenari: A1 s thread at prcessr 0 is sending messages t the ther thread n prcessr 3 ver the path (0 1 3). Simultaneusly, A2 s thread n prcessr 1 is sending a message t the ther thread n 2 ver the path (1 0 2). Figure 8: Messagepassing cntentin In this case, the tw applicatins will cmpete ver the link (0-1) which is channel a. This results in Applicatins Case 1 (4,4) Case 2 (4,4) Case 1 (2,6) Case 2 (2,6) A1 A2 A1: 4p A2: 4p A1: 4p A2: 4p A1: 2p A2: 6p A1: 2p A2: 6p MM MM MM FLOYD MM LU MM FFT MM FDTD FLOYD FLOYD FLOYD LU FLOYD FFT FLOYD FDTD LU LU LU FFT LU FDTD FFT FFT FFT FDTD FDTD FDTD Table 4: Executin times using nn-cntiguus space sharing n eight prcessrs. A2 A2 A2 A2 A2 A1 A2 A1 A1 A1 A1 A2 A2 A1 A1 A2 A2 A2 A1 A2 A1 A2 A2 A1 A2 A2 A2 A2 A1 A2 A1 A2 Case 1 Case 2 Case 1 Case 2 2, 6 2, 6 4, 4 4, 4 Case B Case A Figure 7: Fur scenaris f allcating tw jbs (A1, A2) n the PwerXplrer using (4, 4) and (6, 2) Table 4 shws the same experiment cnducted in table 3; this time the prcessrs f each applicatin are nn-cntiguus. Fur cnfiguratins are tested (as illustrated in figure 7); tw cases fr each cnfiguratin, namely the (4,4) and (2, 6) cnfiguratins. Observatin: (Tables 3 and 4) Nncntiguus allcatin f an applicatin increases the executin time ver cntiguus allcatin by a factr f 1.07 in average and 1.1 in maximum. Nn-cntiguity creates message-passing cntentin when threads f tw different applicatins cmpete ver cmmn cmmunicatin channels. This results in mre delay due t cmmunicatin and thus increases the executin times f the applicatins. Example: Cnsider the case shwn in figure 8: the black and white circles represent prcessrs allcated tw different applicatins, A1 and A2. A1 s threads are running n prcessrs 0 and 3, and A2 s threads are Applicatins 2 prcessrs A1 A2 TS CSS TS CSS TS CSS TS CSS(4, 4,) CSS(2,6) MM MM MM FLOYD MM LU MM FFT MM FDTD FLOYD FLOYD FLOYD LU FLOYD FFT FLOYD FDTD LU LU LU FFT LU FDTD FFT FFT FFT FDTD FDTD FDTD Table 5: Average executin time with time-sharing and cntiguus and nn-cntiguus space sharing cmmunicatin delay, and thus increases the verall executin time f bth applicatins. We dente t the maximum bserved increase in executin time due t nn-cntiguus allcatin ver cntiguus by nc2ctr. We used this value in the simulatin part (see sectin 5 fr details). 6.3 Cmparing Space and Time-Sharing Strategies Table 5 demnstrates the average executin times n 2, 4, 6, and 8 prcessrs using timesharing (TS) and cntiguus space sharing (CSS). Observatin: (Table 5) The rati between executin time f time-sharing and space-sharing applicatins ranges between 0.95 and 1.3. This shws that time-sharing perfrmance is cmparable t cntiguus space sharing. Fr instance, the executin time f LU and Flyd n fur prcessrs using TS and CSS were and Vlume 3 Number 1 Page 51

7 40.1 secnds, respectively. The difference was 4.25 secnds. Observatin: (Table 5) The difference between TS and CSS decreases as the number f prcessrs allcated t the sharing applicatins increases. TS may give shrter executin time than CSS in sme cases (i) depending n the cmmunicatin timing and behavir f the applicatins and (ii) due t lw efficiency values at relatively large Figures 10 and 11 shw the average turnarund time (figure 10) and system utilizatin (figure 11) vs. system lad fr CSS and NCSS (i) withut flding (ii) with bunded flding and (iii) unbunded flding. Observatin: (Figures 10 and 11) Flding is useful as it prvides lw average turnarund time and high system utilizatin at high system lads Tu rn aru nd t im e vs L ad 9 0 S y s t e m u t i l iz a t i n vs Lad Turnarund tim e CS S / N F NC S S / NF CS S / U F NC S S / UF CS S / B F N C SS/ B F S y s tem utiliz at in C S S / N F N C S S / N F C S S / U F N C S S / U F C S S / B F N C S S / B F B e t a Figure 10: System lad (Beta) vs. turnarund time f all allcatin strategies allcatin sizes. Fr instance, in the case f MM B e t a Figure 11: System lad (Beta) vs. System utilizatin f all allcatin strategies Observatin: (Figure 11) Unbunded flding gives T u r nar und t i m e vs Lad ( U n i f r m S i z e D i s t r i but i n) T u r n a r u n d t i m e v s L a d ( u n b u n d e d f l d i n g ) C S S / N F N C S S / N F C S S / U F N C S S / U F Turnarund t im e Turnarund tim e B e t a (a) (b). and LU factrizatin executed n eight prcessrs, the executin time was secnds with TS and 22.5 and 24.6 with CSS n 2-6 and 4-4 distributins respectively. Figure 9: Average turnarund time vs. system lad fr CSS and NCSS (a) withut flding and (b) with unbunded flding B e t a higher system utilizatin than bunded flding, hwever, it gives nticeably higher average turnarund times at high system lads. 6.4 Simulatin Results and Observatins Figure 9 shws the average turnarund time vs. system lad (Beta, which is the mean arrival rate in Pissn prcess). Observatin: (Figure 7 (a) and (b)) Withut flding, NCSS allcatin gives shrter average turnarund time (ATT) than CSS. The CSS allcatin, when unbunded flding is used, gives less ATT than NCSS allcatin. NCCSS utperfrms CSS in terms f average turnarund time when flding is nt supprted. Hwever, when flding is supprted, CSS utperfrms NCCSS and can sustain much higher system lads. 7. Cnclusins and Future wrk We experimentally demnstrated that time-sharing gives cmparable results t space sharing allcatin and may perfrm better at relatively large allcatin size. Simulatin, based n the real bserved executin times f the selected applicatins, shwed that nn-cntiguus allcatin gave better results than cntiguus allcatin when flding is nt supprted. Hwever, when flding is supprted, cntiguus allcatin gave the best mean turnarund times. Vlume 3 Number 1 Page 52

8 As a future wrk, we may perfrm the same study n different cmputer architectures. Als, we may cnduct the same experiment using different parallel prgramming languages t cmpare their perfrmance with different prcessr allcatin strategies. 8. References [0] Fraij, Faris, Cntiguus and Nncntiguus Space Sharing Strategies in Parallel Cmputers, Master thesis, al-albayt University, Jrdan, 1998 [1] Sulieman Bani-Ahmad, Experimental study n Time and Space Sharing n the PwerXplrer, Master thesis, AABU, Mafraq, Jrdan. [2] Addisn C. A., Getv V. S., Hey A. J., Hckney R. W., and Wltn I. C., The GENESIS Distributed-Memry Benchmarks, Jurnal f Cmputer Benchmarks, Vl. 8, 1993, pp [3] Bailey, D. H., The NAS Parallel Benchmarks, Jurnal f Supercmputer Applicatins, vl. 5, n. 3, 1991, pp [4] Breshears, C. P. and Langstn, M. A., Parallel Benchmarks and Cmparisn-based Cmputing. Prceedings f the Internatinal Cnference n Parallel Cmputing, Gent, Belgium, September [5] Sullivan, D. M. Electrmagnetic Simulatin using the FDTD Methd. First editin. IEEE press, New Yrk, [6] Quinn, M. J. Parallel Cmputing Thery and Practice. Secnd editin, McGRAW-HILL Inc, New Yrk, [7] PARSYTEC EASTERN EUROPE GmbH, PARIX, versin PPC Reference Manual, PARSYTEC EASTERN EUROPE GmbH, [8] Zhu, Y. Efficient Prcessr Allcatin Strategies fr Mesh-cnnected Parallel Cmputers, Jurnal f parallel and distributed cmputing, Vl. 16, 1992, pp [9] D. Feitelsn, L. Rudlph, and U. Schwiegelshhn. Parallel Jb Scheduling -- a Status Reprt. In 10th Wrkshp n Jb Scheduling Strategies fr Parallel Prcessing, New-Yrk, NY, June [10]Fster, I. T., Designing and building parallel algrithms. First editin, Addisn-Wesley Publishing Cmpany, Massachusetts, [11]Feitelsn D., A Survey f Scheduling in Multiprgrammed Parallel Systems, IBM research reprt RC (87657), Revised versin, [12]Ismail, I. M. and Davis, J. A., Adaptive Run-tcmpletin Jb Scheduling Plicies fr Parallel Cmputers, prceedings f Internatinal cnference n electrnics, circuits and systems, December 1995, pp (a) [13]L, V., Windish, K. Liu, W. and Nitzberg, B. Nn-cntiguus Prcessr Allcatin Algrithms fr Mesh-Cnnected Multiprcessrs, IEEE transactins n parallel and distributed systems, 1997, pp [14]L P Sants, V Castr, A. Prenca. Evaluatin f the Cmmunicatin Perfrmance n a Parallel Prcessing System. Prceedings f the 4th Eurpean PVM/MPI Users' Grup Meeting, [15]Mark Crvella, Ricard Bianchini, Thmas J. LeBlanc: Using Cmmunicatin-t-Cmputatin Rati in Parallel Prgram Design and Perfrmance Predictin. SPDP Vlume 3 Number 1 Page 53