De volgorde van een linked list omkeren

Transcriptie

1 De volgorde van een linked list omkeren Inleiding Daniel von Asmuth 21 januari 2015 Hierin presenteren we een algoritme om de volgorde van de knopen in een linked list om te keren dat wordt versneld door meerdere processoren tegelijk te gebruiken. Wikipedia ( geeft een goede introductie over linked lists. Eenvoudig gezet bestaan ze uit een geordende rij van nul of meer objecten waarin elke knoop de gegevens van een object bevat plus een wijzer naar het volgende element. Anders dan bij Wikipedia staat gebruiken we geen speciale terminator knoop, maar een speciale wijzer (NIL of NULL) om aan te geven dat er geen volgende knoop meer is. I. Implementatie van een linked list Wikipedia stelt dat de enige manier om een linked list te verwerken daaruit bestaat dat je een wijzer gebruikt naar het eerste element van de lijst en van daaruit telkens de wijzer naar het volgende element volgt, totdat er geen volgende element meer is. We kunnen een lege lijst representeren door de wijzer naar de kop de waarde NIL te geven. Voor parallelle verwerking kun je de lijst in de voorgeschreven volgorde aflopen en telkens het adres van een knoop aan een nieuwe thread meegeven, maar voor lange lijsten is dat niet efficient. De meest voor de hand liggende datastructuur is het array (de rij). In theorie kunnen alle elementen daarvan tegelijkertijd worden gelezen of geschreven; in de praktijk laat de hardware dat niet toe, maar het is wel de snelste methode. Het artikel in Wikipedia beschrijft ook alternatieven, genaamd 'dynamic arrays' en 'linked lists using arrays of nodes', maar mist het punt dat die parallelle toegang mogelijk maken. Voor dit artikel is een knoop een object of tupel dat een getal bevat, plus de index van het volgende element; een lijst is dan een object (in C heet dat 'struct') dat een rij van knopen bevat, plus het aantal elementen in de lijst en wijzers naar de eerste en laatste node. De programmacode staat aan het eind van dit artikel. De basisfuncties zijn init() om een lijst leeg te maken, insert() om een element toe te voegen, delete() om een opgegeven element te verwijderen en print() om alle getallen af te drukken. De belangrijkste eigenschap is dat de posities 0 t/m count 1 in gebruik zijn met als gevolg dat je na het wissen van een element de laatste knoop naar de vrije positie moet verplaatsen. Daarom is gekozen voor een dubbel gelinkte lijst. Een andere eigenaardigheid is dat de print() functie de getallen in de omgekeerde volgorde afdrukt als waarin ze zijn ingevoerd. II. Een lijst omkeren Sommige functies zijn niet afhankelijk van de volgorde van de elementen, zoals het vinden van het grootste en kleinste getal of het sorteren van de lijst, en kunnen daarom gemakkelijk parallel worden uitgevoerd. Voor functies die dat wel zijn, hanteren we het verdeel en heers paradigma. In dit geval hoeven we de lijst niet eerst op te delen, maar beginnen we met n deellijsten van elk 1 element; vervolgens moeten we n 1 keer telkens twee deellijsten samenvoegen om uiteindelijk 1 deellijst met alle elementen over te houden.

2 De gewenste functie moet triviaal zijn voor een verzameling met 1 element en de resultaten van twee deelverzamelingen moeten snel gecombineerd worden kunnen worden. Voor ons probleem geldt dat een lijst met 1 element gelijk is aan zijn omgekeerde en twee deellijsten, waarvan de inhoud al is omgekeerd kunnen we samenvoegen door hun volgorde te verwisselen. De kop van een deellijst is telkens de knoop i en het array tails wijst naar de laatste knoop. h p i j1 n1 j2 n2 t Het moeilijke werk gebeurt in functie reverse2, die voor elke knoop i aangeroepen wordt om de deellijst i.. j1 te verplaatsen naar achter de volgende deellijst n1.. j2, waartoe de drie doorgetrokken pijlen worden omgeleid naar volgens de drie gestreepte pijlen onder en bovenaan. De variabele h verwijst hier naar de kop van de lijst, t naar de staart, p naar de knoop voor i, en n2 naar de knoop na j2. De eerste keer is j1 gelijk aan i en j2 aan n1. De wijzers naar de voorafgaande knoop worden eveneens aangepast en tails[n1] verwijst naar de knoop j1. Daarna hoeven enkel de wijzers naar de kop en de staart te worden verwisseld. Als we de inhoud van de lijst voor aanroep van reverse2 weergeven als de preconditie L = H L 1 L 2 T met H = h p, L 1 = i j 1, L 2 = n 1 j 2, T = n 2 t dan worden de twee deellijsten tot verwisseld tot: L' = H L 2 L 1 T na samenvoegen van deellijsten wordt de invariante conditie: L = H D T Als L een lege lijst is wordt de functie niet aangeroepen, dus L 1 is een deellijst met tenminste 1 knoop, terwijl de rest eventueel leeg kan zijn, maar anders zijn het reeksen van deellijsten. De invariant wil zeggen dat de lijst bestaat uit een reeks deellijsten, zodanig dat de knopen van de deellijsten al zijn omgekeerd, maar de volgorde van de deellijsten nog is zoals in de beginsituatie. Aanvankelijk zijn dat n deellijsten met 1 element, uiteindelijk 1 deellijst met n elementen. Die functie zet eerst de lokale variabelen goed: j1 = tails[i]; n1 = list >nodes[j1].next; /* The second sublist */ if( n1 == NIL) return; j2 = tails[n1]; n2 = list >nodes[j2].next; /* Node after second sublist */ Merk op, dat als de tweede deellijst leeg is, de staart is bereikt, zodat de functie niets hoeft te doen. Vervolgens leiden we de wijzers om, zoals in de figuur is getekend. list >nodes[j2].next = i; list >nodes[j1].next = n2; if( preds[i]!= NIL) /* Node before first sublist */ list >nodes[preds[i]].next = n1; Net zo passen we de wijzers naar de voorafgaande knoop aan en voegen de deellijsten samen. list >nodes[n1].prev = p; list >nodes[i].prev = j2; if( n2!= NIL) list >nodes[n2].prev = j1; tails[n1] = j1;

3 III. Parallelle verwerking We lopen de programmacode langs; in de functie main worden de deellijsten geïnitialiseerd. for( i = 0; i < N; i++) tails[i] = NIL; for( i = 0; i < list.count; i++) tails[i] = i; In de functie reverse worden de threads gestart, die alle reverse1 aanroepen, dat de nodige mutexen aanmaakt en reserveert, zodat voor alle waarden van i tussen 0 en n 1, reverse2(i) aangeroepen wordt. Terug in reverse worden de wijzers naar de kop en staart verwisseld. i = list >head; /* swap head & tail pointers */ list >head = list >tail; list >tail = i; We merken op dat na uitvoering van reverse2(i) telkens de deellijst i afgewerkt is en dat de conditie n1 == NIL alleen optreedt als deellijst i de laatste in de lijst is. Samen met de invariant volgt dat aan het eind nog 1 deellijst over is met de knopen van de oorspronkelijke lijst in omgekeerde volgorde. De functie reverse2 vergt ten hoogste een constant aantal rekenstappen, wat we noteren als t = O(1). Als we ze sequentieel uitvoeren dan kost dat O(n) rekentijd. Vergeleken met een pure linked list implementatie is het waarschijnlijk iets langzamer omdat de index berekening van de arrays een optelling vereist, maar het blijft O(n). De clou van dit algoritme is dat het correct werkt ongeacht de volgorde, zolang reverse2 maar voor elke knoop i wordt aangeroepen. De knopen kunnen ook gelijktijdig worden afgewerkt, als we de knopen i, n1 en n2 reserveren, zodat andere threads moeten wachten voordat ze bij die knopen kunnen en de thread waarvoor p de laatste knoop is de knopen i en n1 niet kan reserveren. Als er n threads zijn, zal een derde deel daarvan door kunnen gaan; de volgende ronde een derde deel van het restant enzovoorts, zodat de doorlooptijd O( 2 log(n)) wordt. De meeste computers gebruiken tegenwoordig Symmetric MultiProcessing, wat neerkomt op een klein aantal processoren of cores, die via een gemeenschappelijke bus of crossbar switch verbonden zijn met een gedeeld geheugen; een andere groep werkt met Non Uniform Memory Access, wat betekent dat elke processor een lokaal geheugen heeft waar andere processoren langzamer bij kunnen. Supercomputers bestaan doorgaans uit meerdere computers die via een snel netwerk gegevens uitwisselen zonder toegang tot elkaars geheugen. Het algoritme is geoptimaliseerd voor een SMP systeem door het aantal threads p te kiezen als 2 maal het aantal cores. Daarmee worden telkens 3 * p mutexen gereserveerd, waardoor de kans dat een thread op een andere moet wachten klein is en als een thread geblokkeerd is, een andere thread de processor krijgt. Zodoende kost de uitvoering O(n/p) rekentijd. Een groter aantal threads heeft weinig zin. Deze combinatie van parallelle en sequentiële uitvoering blijkt simpel te realiseren zodat alle threads evenveel werk doen. Het aantal mutexen is gekozen tussen n en p voor een compromis tussen de tijd om ze aan te maken en de tijd die we met wachten verliezen. Conclusie Een linked list kan in willekeurige volgorde worden verwerkt door de knopen in een array op te slaan. Dat kan handig zijn als objecten meerdere volgordes hebben: bijvoorbeeld een verzameling personen, die zowel op naam als op leeftijd zijn gerangschikt. Dit algoritme is in theorie even snel als de links te volgen en in de praktijk ook snel genoeg. Op een SMP systeem is het optimaal met een rekentijd van O(n/p) stappen voor n knopen en p processoren.

4 C programma code geschreven onder Windows Listing 1. Linked list omkeren #include <stdio.h> #include <stdlib.h> #include <time.h> #include <Windows.h> #include <process.h> #define N /* maximum nr. of list elements */ #define M 1000 /* range of numbers */ #define P 8 /* 2 threads per core */ #define X /* number of mutexes */ #define NIL 1 /* invalid array index */ typedef struct _node int key; /* data */ int next; /* pointer to next node */ int prev; /* pointer to previous node */ NODE; typedef struct _list int head; /* point to first and last node */ int tail; /* NIL denotes end of the list */ int count; /* number of elements */ NODE nodes[n]; /* fixed maximum size */ LIST; LIST list; /* contains the data */ int tails[ N]; /* defines temporary sublists */ HANDLE mutexes[ X]; /* ensure 1 thread changes node */ HANDLE threads[ P]; /* parallel tasks */ /* Elementary linked list operations */ /* We use an array to hold the nodes that we manage such that nodes */ /* 0..n 1 always contain valid elements */ /* initialise an empty list */ init( LIST *list) int i; list >head = list >tail = NIL; list >count = 0; for( i = 0; i < N; i++) list >nodes[i].next = NIL; list >nodes[i].prev = NIL; /* new nodes are inserted at the front of the list */ /* this more or less reverses it */ insert( LIST *list, int key) if( list >count == N) printf( "The list is full!\n"); return; if( list >tail == NIL) list >tail = list >count; list >nodes[ list >head].prev = list >count; list >nodes[ list >count].next = list >head; list >head = list >count; list >nodes[ list >count++].key = key;

5 /* remove a node from the list */ /* we may have to move a node to preserve the structure */ delete( LIST *list, int i) int h, n, p; list >count ; h = list >head; p = list >nodes[i].prev; /* Relink previous node */ if( p!= NIL) list >nodes[p].next = list >nodes[i].next; if( list >nodes[i].next!= NIL) list >nodes[list >nodes[i].next].prev = p; /* Adjust the head and tail */ if( i == list >head) list >head = list >nodes[i].next; if((i == list >tail) && (p!= NIL)) list >tail = p; list >nodes[p].next = NIL; if( list >count!= i) /* Relink semifinal node */ p = list >nodes[list >count].prev; if( p!= NIL) list >nodes[p].next = i; n = list >nodes[list >count].next; if( n!= NIL) list >nodes[n].prev = i; /* Adjust the head and tail */ if( list >count == h) list >head = i; if( list >count == list >tail) list >tail = i; /* move the last entry to the freed position */ list >nodes[i] = list >nodes[list >count]; /* clear the freed node */ list >nodes[list >count].key = 0; list >nodes[list >count].next = NIL; list >nodes[list >count].prev = NIL; print( LIST *list) int i,j; printf( "The list: \t"); for( i = list >head, j = 1; i!= NIL; i = list >nodes[i].next, j++) printf( "%03d ", list >nodes[i].key); if( j > N) printf( " \n **** ERROR **** \n\n"); exit( 2); printf( "\n"); /* Fill the list with random test data */ fill_random( LIST *list) int i; init( list); srand( (int) time( 0)); for( i = 0; i < N; i++) insert( list, (rand() % (M 3) + 3));

6 /* Delete a few random elements from the list */ test_deletion( LIST *list) int i, next; for( i = list >head; i!= NIL; i = next) next = list >nodes[i].next; if(!(list >nodes[i].key % 3)) delete( list, i); /* Combine the sublists starting at nodes i and n1 into one */ /* Precondition: the elements of sublist i and n1 are already handled */ /* except for the heads. */ reverse2( LIST *list, int i) int j1, j2, n1, n2, p; /* find next sublist n1 and the one after that (n2) */ j1 = tails[i]; n1 = list >nodes[j1].next; /* The second sublist */ if( n1 == NIL) /* We have reached the last node */ return; j2 = tails[n1]; n2 = list >nodes[j2].next; /* Node after second sublist */ p = list >nodes[i].prev; /* concatenate the sublists */ list >nodes[j2].next = i; list >nodes[j1].next = n2; if( p!= NIL) /* Node before first sublist */ list >nodes[p].next = n1; /* swap pointers for the predecessor nodes */ list >nodes[n1].prev = p; list >nodes[i].prev = j2; if( n2!= NIL) list >nodes[n2].prev = j1; /* join two sublists */ tails[n1] = j1; /* obtain exclusive access for nodes and let reverse2() do the actual work */ /* this function is run by each thread simultaneously */ /* each thread performs count / P iterations */ unsigned int stdcall reverse1( int p) DWORD status; int i, j1, n1, j2, n2; for( i = p; i < list.count; i += P) while( TRUE) /* try to obtain mutexes */ status = WaitForSingleObject( mutexes[i], 9); if( status!= WAIT_OBJECT_0) continue /* try again */ /* find next sublist n1 */ j1 = tails[i]; n1 = list.nodes[j1].next; /* The second sublist */ if( n1 == NIL) break; /* one mutex is enough here */ j2 = tails[n1]; n2 = list.nodes[j2].next; /* Node after second sublist */

7 if( n1 % X!= i % X) status = WaitForSingleObject( mutexes[n1 % X], 0); if( status == WAIT_OBJECT_0) if( n2 == NIL) break; /* two mutexes is enough here */ if((n2 % X!= n1 % X) && (n2 % X!= i % X)) status = WaitForSingleObject( mutexes[n2 % X], 0); if( status == WAIT_OBJECT_0) break; /* success */ ReleaseMutex( mutexes[n1 % X]); /* failed so release the mutex */ ReleaseMutex( mutexes[i % X]); /* failed so release first mutex */ /* now we own both mutexes */ reverse2( &list, i); /* so we can safely proceed */ ReleaseMutex( mutexes[n2 % X]); /* return codes not checked here */ ReleaseMutex( mutexes[n1 % X]); ReleaseMutex( mutexes[i % X]); /* release all three mutexes */ _endthreadex( 0); /* now end this thread */ return 0; /* never reached */ /* reverse the elements of the linked list */ reverse( LIST *list) int i; unsigned int id; for( i = 0; i < X; i++) /* create enough mutexes */ if((mutexes[i] = CreateMutex( NULL, FALSE, NULL)) == NULL) printf( "CreateMutex() failed. \n"); exit( 2); printf( "Starting %0d threads for %0d nodes. \n", P, list >count); for( i = 0; i < P; i++) /* create a thread for each node */ threads[i] = (HANDLE) _beginthreadex( NULL, 0, reverse1, (void *) i, 0, &id); if( threads[i] == NULL) printf( "BeginThreadEx() failed \n"); exit( 2); /* wait up to 100 seconds for the other threads to finish */ if((int) WaitForMultipleObjects( P, threads, TRUE, ) > list >count) printf( "Wait failed \n"); exit( 2); printf( "Back to 1 thread. \n", P); for( i = 0; i < P; i++) /* clean up threads & mutexes */ CloseHandle( threads[i]); for( i = 0; i < X; i++) CloseHandle( mutexes[i]); i = list >head; /* swap head & tail pointers */ list >head = list >tail; list >tail = i; int main( void) int i; printf( "Starting 1 thread. \n"); /* initialisation of linked data list */ fill_random( &list); init( &copy); test_deletion( &list); for( i = list.head; i!= NIL; i = list.nodes[i].next) insert( &copy, list.nodes[i].key);

8 /* initialisation of auxiliary data */ for( i = 0; i < N; i++) tails[i] = NIL; for( i = 0; i < list.count; i++) tails[i] = i; /* now do it */ // print( &list); reverse( &list); // print( &list); exit( 0);