Algorithm for Equal Distribution of Identical Elements on One Dimensional Field

Transcription

1 Algorthm for Equal Dstrbuton of Identcal Elements on One Dmensonal Feld Mate Boban, Alen Lovrenčć Unversty of Zagreb, Faculty of Organzaton and Informatcs, Varaždn, Croata Mchael Kreutzer Technsche Unverstät Darmstadt, Darmstadt Centre for IT Securty Abstract: Ths paper descrbes an algorthm for an equal dstrbuton of m dentcal elements on onedmensonal feld of sze n wth m < n. Durng the development of the dscrete event smulaton of MANET (Moble Ad Hoc Networ), the need for equal dstrbuton of specal node roles (e.g. servers, clents or drectores) on the nodes had occurred. The soluton usng some of the exstng random number generators was out of the queston because we wanted to now to whch node had the role been assgned to so we needed an algorthmc soluton n order to predct on whch node whch types of roles wll be placed, f any. In the proposed algorthm, two specfc cases are regarded: trval case wth dstrbuton (n mod m) = 0, where every (n dv m) element of n s selected, and (n mod m) 0, where we mplement our algorthm. We show that usng the proposed algorthm the m elements are equally dstrbuted over sze n one-dmensonal feld. The algorthm s gven n pseudo-code and thoroughly commented. Keywords: one-dmensonal feld, algorthmc soluton. INTRODUCTION Durng the development of the dscrete event smulaton of MANET (Moble Ad Hoc Networ) for the purposes of the ARDOR project [5], we have come across the problem of specal node roles dstrbuton. Specfcally, when we were developng Java mplementaton of the servce dscovery protocol called HYDRA [6], we needed the algorthm whch wll dstrbute each of the node roles (namely clent, server and drectory) on the nodes n a way that we are able to determne where each of the node roles wll be placed, so we can set up the smulaton accordng to our preferences. The mportant fact s that the number of each node role (lets denote them wth m) s less than the number of the nodes (lets denote them wth n). The soluton where we dstrbute node roles every p = n m, was not satsfactory, because t would mean that there would be q (q = n mod m) nodes at the end of the nodes array that would not have node role assgned. Also, mplementng some of the random number generator functons was out of the queston, because the smulaton preferences couldn't be set up properly. Because of ths, we needed a soluton whch wll dstrbute node roles n a way that the mnmum dstance between two employed nodes s p, where p = n m, and the maxmum dstance s p+, where we have q (q = n mod m) of the sze p+ dstances, and m--q dstances of sze p. Also, the second condton the algorthm had to fulfll s that sze p and p+ dstances between employed nodes are unformly dstrbuted across the nodes, so that each node has equal "chance" to get each node role. Concernng the smulaton, t was mplemented n JST/SWANS (Java n Smulaton Tme/Scalable Wreless Ad hoc Networ Smulator, [3]) smulaton envronment. The rest of ths paper s structured as follows: We gve a formal descrpton of problem n Secton, provng that PS and GD problems are equvalent and defnng the optmal soluton to PS and GD problems. In Secton 3 we present a smple algorthmc soluton to the problems, whereas n Secton 4 we enhance the algorthmc soluton so the m- gaps of sze p and p+ are unformly dstrbuted across n (the number of nodes). Fnally, the paper concludes n Secton 5.

2 . FORMAL DESCRIPTION The problem we want to solve can be formally wrtten as followng: Process schedulng (PS): There are m processes and n processors, where m n. We have to dstrbute processes to processors n a way that maxmzes mnmal dstance between two employed processors, as well as t mnmzes maxmal dstance between processes. Formally, we have: x x < x mn j j max j j { } {,..., m,..., m} { } {,..., m,..., m} {,..., n}, where {,..., m} j where < j ( x x ) + ( x x ) + max mn Ths problem t rather unusual optmzaton problem, because t has two optmzaton functons whch have to be consdered. Example: Let we have 7 processors and 8 processes. Then optmal dstrbuton s gven wth followng vector (, 4, 6, 8, 0,, 4, 7). Gap Dstrbuton (GD): There s also an alternatve approach to the problem. We have m- gaps between employed processors. The gap sze s gven by formula δ =x + -x. Sum of all dstances should be n-. Now the problem could be formally wrtten as follows: m δ = n = mn δ max {,..., m } max δ mn {,..., m } Proposton : Problems PS and GD are equvalent problems. Proof: Let we have m processes and n processors. Then we clearly have m- dstances. Let (x,, x n ) be soluton for PS problem. Then vector (x -x,, x n -x n- ) gves soluton of problem GD, and vce versa. Q.E.D. Soluton : Let n be the number of processors and m number of processes. The nteger dvson of (n- ) and (m-) gves (n-)/(m-)=p (n-)=q mod (m-) Then we clam that optmal soluton to GD problem s every vector that has q values of p+ and n-q- values p. Theorem : Soluton descrbed n Soluton s optmal for GD problem. Proof: We have to prove that there s at least one gap that s less or equal to p. For m= the problem s trval. Let us assume therefore that m>. Let us assume that all gaps are greater than p. That means that all gaps are greater or equal to p+. It s easy to see that f there s m processes then there s m- gaps. Let x,, x m- be these gaps. Now we have m = x ( m ) ( p + ) = ( m ) p + ( m ) = n + m > n But ths s contradcton. So, we conclude that assumpton that all gaps are greater than p s wrong. In

3 other words, at least one of the gaps has to be less or equal to p. It s easy to see, by the defnton of the GD problem that m = x = n Let us assume that (n-) = q mod (m-) Then n = ( m ) p + q If q=0 then t s obvous that optmal soluton has to have all gaps of sze p. Let q>0. In ths case we have at least one gap whose sze s greater than p. In the other words, there has to be at least one gap wth sze greater or equal to p+. So, by the mnmzaton condton, t would be optmal f we could mae a decson wth maxmal gap of sze p+. But, as q<(m-), we can mae soluton that has q gaps of sze p+, and m-q- gaps of sze p. The wanted soluton s Soluton. Therefore, the soluton s optmal for GD problem. Q.E.D. Therefore, we have a very smple algorthm whch gves an optmal soluton of PS problem. 3. ALGORITHMIC SOLUTION Gap sze 4 3 Gap dstrbuton n = 6, m = Dstance between: Fgure. Algorthm gap dstrbuton Pseudo-code of Algorthm : CLASS dstrbute(n,m) //n represents number of processors, whle m represents number of processes nt p = (n-)/(m-) //we use n- and m- because frst process always goes //to frst processor nt q = (n-)mod(m-) CREATE ntegerarray[m-] //create nteger array of gaps FOR counter = 0 TO q DO ntegerarray[counter] = p+ //set frst q gaps to sze p+ ENDFOR FOR counter = q+ TO m- DO ntegerarray[counter] = p //set the rest of the gaps to sze p ENDFOR ENDCLASS Bascally, Algorthm dstrbutes gaps n a way that t sets the frst q gaps to sze p+, and the rest of the gaps (m-q-) to sze p. For example, f n = 6, m =, Algorthm wll place gaps as shown n Fg.. It s easy to see that ths algorthm has complexty of O(m), where m s number of processes. 4. ENHANCED ALGORITHMIC SOLUTION There s one more condton that we want to nclude n our soluton. Algorthm gves soluton that maes the frst q gaps of sze p+ and the last m-q- gaps of sze p. We want to fnd a soluton n whch gaps of sze p+ are unformly dstrbuted through the number of processors. Algorthm :

4 To create a soluton n whch gaps of sze p+ are unformly dstrbuted, we devsed an algorthm where we frst mae all the m- gaps of sze p, and afterwards we add the q of the remanng p+ gaps onto the gaps array replacng the exstng sze p gaps wth sze p+ gaps n the followng manner: Frst, we determne the mddle gap,.e. we fnd the mddle of the sze m- gaps array ; f m necessary, the value s rounded up to celng (.e. mddle = ). In the mddle element of the gaps array we replace sze p gap wth sze p+ gap. In the same (quc sort) manner, we are determnng the mddle of the newly created gaps array parts and placng sze p+ gaps nstead of sze p gaps on the mddle elements. Ths means that n the frst teraton over gaps array we are placng one sze p+ gap, n the second two sze p+ gaps, then 4, 8, 6, 3 etc. + So, we have = where equals the number of teratons over sze m- gaps array. = When we now ths, t s easy to calculate how many teratons we wll need to place q gaps of sze p+ over sze m- gaps array : + q + q + / log ( + ) log log( q + ) log( q + ) + log log( q + ) log. e. log( q + ) = log We are sure we wll be able to replace q sze p gaps wth sze p+ gaps n the teraton. However, t s obvous that we wll be able to unformly dstrbute q gaps over m- sze gaps array only f q = j, where j {,,3,... } (f q j, then the last teraton wll not reach the end of the gaps array, thus leadng to non-unformed dstrbuton). t log(q + ) Because of that, we frst dstrbute q gaps of sze p+, where t =. By dong log ths, we ensure that t gaps of sze p+ wll be unformly dstrbuted over m- sze gaps array. t Now we have z = q of sze p+ gaps left to dstrbute, and we wll dstrbute them n the r log(z + ) same manner,.e. n the next teraton we wll dstrbute z, where r = and log so on, untl there s no sze p+ gaps to dstrbute. Ths ensures us much better soluton to the GD (Gap Dstrbuton) problem. Pseudo-code of Algorthm : In pseudo-code we are usng the concept of borders: we ntroduce (left, rght) pars of borders for dstrbuted sze p+ gaps to ease the calculaton of the mddle element ("mddle gap") n the "gaps array". Therefore, the borders array s created. The frst (left, rght) par s the frst and the last element of the "gaps array"; (left, rght) = (0, m-). Example: m- = 9, q = 3 ndex: start p p p p p p p p p left,rght par: (0,8)

5 ndex: st teraton p p p p p+ p p p p left,rght pars: (0,3);(5,8) ndex: nd teraton p p p+ p p+ p p p+ p left,rght pars: (0,);(3,3);(5,6);(8,8) Table. Placement of the borders CLASS dstrbute(n,m) //n represents number of processors, whle m represents number of processes CREATE ArrayLst //create arraylst of sze 0 leftborder = //frst value of left border s zero rghtborder = no_of_nodes //frst value of rght border s the number of nodes arraylst.add(leftborder) //nsert left border arraylst.add(rghtborder) nt p = (n-)/(m-) nt q = (n-)mod(m-) CREATE ntegerarray[m-] //nsert rght border //we use n- and m- because frst process always //goes to the frst processor //create nteger array of gaps FOR counter = 0 TO m- DO ntegerarray[counter] = p //set all gaps to sze p ENDFOR nt = floor(log(q+)/log()) - log(q + ) = log nt SumOfPowerOfTwo = power(,) - //n frst teraton, we wll dstrbute p+ gaps WHILE(SumOfPowerOfTwo > 0) DO mddle = celng((leftborder+rghtborder)/) //fnd the mddle of the observed part of the gaps array, round t up to celng. ntarray[mddle++] //the gap n the mddle of the observed part of the nodes array becomes p+ poweroftwo-- //subtract one gap change At ths pont, we had splt our observed part of the nodes array nto two (as smlar n sze as possble) parts, so now we have to add two new borders, one wth the value that s (mddle - ); ths border s referred to as rghtborder and another wth the value (mddle + ); ths border s referred to as leftborder. Orgnal leftborder and rghtborder wll be the new (left, rght) par n the ArrayLst, and so wll leftborder and orgnal rghtborder. leftborder = mddle + rghtborder = mddle - The next part of the code s executed f the orgnal (n ths teraton) leftborder s less or equal to the new rghtborder AND f the orgnal (n ths teraton) rghtborder s not the last border n array,.e. t s not representng the last element of the "gaps array". IF (leftborder <= rghtborder) AND (rghtborder < no_of_nodes) THEN IF (leftborder + == rghtborder) THEN //don t add borders, leftborder and rghtborder are next to each other, //so we just fetch the next left rght border par store = arraylst. IndexOf(rghtBorder) left = arraylst.get(store + ) rght = arraylst.get(store + ) ELSE //add new borders store = arraylst.indexof(leftborder) //nsert rghtborder and leftborder between left and rght

6 arraylst.add(store +,rghtborder) arraylst.add(store +,leftborder) store = arraylst.indexof(rghtborder) //fetch the next left rght border par leftborder = arraylst.get(store + ) rghtborder = arraylst.get(store + ) The next part of the code s executed f the orgnal (n ths teraton) leftborder s less or equal to the new rghtborder: f leftborder and rghtborder are next to each other, we wll not add borders between them because t maes no sense, and f they are not next to each other we add a new border par. In both cases we are startng the next whle loop step from the start of the borders array. ELSEIF (leftborder <= rghtborder) THEN IF (leftborder + == rghtborder) THEN //don t add borders, leftborder and rghtborder are next to each other left = arraylst.get(0) // fetch the next left, rght border par rght = arraylst.get() ELSE store = arraylst.indexof(leftborder) //nsert rghtborder and leftborder between orgnal borders arraylst.add(store +,rghtborder) arraylst.add(store +,leftborder) //fetch the frst left rght border par of ArrayLst leftborder = arraylst.get(0) rghtborder = arraylst.get() The next part of the code s executed f the orgnal (n ths teraton) leftborder s equal to orgnal (n ths teraton) rghtborder (.e. leftborder = rghtborder). If we haven't reached the end of the borders array, we fetch the next (left, rght) par, else we start from the begnnng of the array. ELSEIF (leftborder == rghtborder) THEN IF((arrayLst.sze- > arraylst.ndexof(rghtborder))then store = arraylst.indexof(rghtborder) //fetch the next left rght par leftborder = arraylst.get(store + ) rghtborder = arraylst.get(store + ) ELSE //fetch the frst left rght par of ArrayLst leftborder = arraylst.get(0) rghtborder = arraylst.get() ELSE brea ENDWHILE IF q = SumOfPowerOfTwo THEN end algorthm //f q = ELSE nt remander = q - power(,) - //we stll have q gaps to dstrbute reman(num_of_border_pars, remander) If q there are stll some sze p+ gaps to dstrbute and we have mplemented recursve functon to dstrbute q of sze p+ gaps over the created border pars: actually, the remander of sze p+ gaps wll be placed n the mddle of the border pars, each sze p+ gap deletng the border par nsde whch t s placed (ths s done to enhance the unformty of dstrbuton: f we delete the border par nsde whch a gap replacement happens, we are sure no more gap replacements

7 wll occur between deleted borders par. Ths means that n the followng recursve functon, gap replacements wll happen only once between the created borders). FUNCTION reman (Num_of_border_pars, remander) IF (remander == ) THEN PowerOfTwo = //f we have just one p+ gap to place ELSE nt = celng(log(remander)/log()) - PowerOfTwo = power(, ) IF (remander > 0) THEN nt step = Num_of_border_pars/PowerOfTwo //calculate the step for gap dstrbuton Num_of_border_pars = Num_of_border_pars - PowerOfTwo //deduct the border pars that wll be removed n ths recurson leftborder = arraylst.get(0) rghtborder = arraylst.get() //fetch the frst border par remander = remander - PowerOfTwo //deduct the number of gaps that wll be placed n ths recurson WHILE (PowerOfTwo > 0) DO mddle = celng((leftborder+rghtborder)/) //fnd the mddle of the observed part of the gaps array, round t up to celng. ntarray[mddle++] //the gap n the mddle of the observed part of the nodes array becomes p+ //nstead of p. arraylst.remove(left) //remove the (left,rght) border par arraylst.remove(rght) leftborder = arraylst.get(store + *step - ) rghtborder = arraylst.get(store + *step) //get the next (left,rght) border par usng stored ponter and step of gaps //placement store = arraylst.indexof(rght) //set the ponter to rght border PowerOfTwo-- ENDWHILE reman(num_of_border_pars, remander) ELSE END ALGORITHM ENDFUNCTION ENDCLASS t In ths functon n each recurson we are dstrbutng gaps, where each placed gap deletes the border par nsde whch t s placed. We are able to do t because we have created border pars, ( > t) and t t, mod = 0 so we are sure recurson wll termnate approprately and all the p+ sze gaps wll be placed nstead of the p sze gaps. As an example, Fg. shows Algorthm gap dstrbuton usng the same n and m values (n = 6, m = ) used by Algorthm shown n Fg. Gap sze 4 3 Gap dstrbuton n = 6, m = Dstance between: Fgure. Algorthm gap dstrbuton

8 Let us see the complexty of ths algorthm. The frst part of the algorthm, n whch we mae all gaps of dstance p, s very smlar to the basc algorthm and has complexty of O(n). The complexty of second part of the algorthm s not so obvous. In ths part of the algorthm we use dvde-and-conquer method, and the complexty of ths part wll be presented by dvde-and conquer recurson: T ( m) = c + T ( m ) Let us use substtuton s = T ( ) () Then ( T ( ) = s = c + T ) = c + T ( ) = c + s The recurson s = c + s has soluton s = C + C (see []). But, because of substtuton () we have the followng formula: T ( m) C + C m That means that the second part of the algorthm has also complexty of O(m), so we can conclude that algorthm has as well as algorthm, complexty of O(m). 5. CONCLUSION In ths paper we develop an algorthm for unform dstrbuton of specfc node roles (clent, server and drectory) across the nodes. We fulfll the demands of the mnmum dstance between two employed nodes, p, where p = n m, and the maxmum dstance, p+, and we also fulfll the demand of unform dstrbuton of the p and p+ dstances across the nodes. There has been a lot of smlar wor n the feld of optmal puncturng scheme for the selecton of the bts for retransmsson n forward error correcton (FEC) and Channel codng [], []. The mnmal dstance between punctured bts s needed n puncturng algorthm also. However, wth puncturng, there s one more constrant: punctured bts have to be dstrbuted on all frames evenly, frames beng represented by two dmensonal array, each frame beng one column. Ths mples that some of the p+ dstances wll be changed n p, resultng wth sub optmal number of p and p+ dstances. Algorthm we developed has exactly q (q = n mod m) of the sze p+ dstances and the rest of the dstances s sze p. Also, algorthm has complexty of O(m), m beng the number of roles to dstrbute. Future research we ntend to conduct ncludes development of the algorthm for unform dstrbuton of the specal node roles regardng already dstrbuted roles of dfferent type. Specfcally, algorthm presented n ths paper, although t dstrbutes roles of one type as evenly as possble, t does not consder the collson of dfferent types of node roles. We ntend to ncorporate "role awareness" n our presented algorthm. REFERENCES [] 3GPP TSG RAN WG (999) R Optmsed puncturng scheme for Turbo codng Fujtsu. [] 3GPP TSG RAN WG (999) R-9964 Propertes of optmsed puncturng scheme, Semens. [3] Barr, Rmon (004) Java n Smulaton Tme/Scalable Wreless Ad hoc Networ Smulator, [4] Dvja,B.; Lovrenčć, A. (005) Dsretna matemata s teorjom grafova (Dscrete Mathematcs wth Graph Theory), TIVA-FOI, Varaždn [5] Kreutzer, Mchael; Kähmer, Martn (004) Ubqutous Computng Technology n Infrastructureless Envronments, Proceedngs of the IEEE Internatonal Conference on Systems, Man and Cybernetcs (IEEE SMC 004). Den Haag, Nederland 004. [6] Kreutzer, Mchael; Kähmer, Martn; Magdc, Karlo (004) Scalable Servce Dscovery n MANETS exemplfed n Moble Hosptals, IADIS e-socety, Avla, Span 004.