211service.com
Eenvoudiger programmeren voor multicore-computers
Het aantal kernen - of rekeneenheden - in microprocessors verdubbelt met elke generatie, wat een enorm computerpotentieel biedt voor desktops, laptops en uiteindelijk draagbare gadgets. De huidige quadcore-machines zijn bijvoorbeeld bijzonder nuttig voor rekenintensieve toepassingen als videoverwerking en gaming. De nieuwe multicore-machines zijn echter in feite kleinschalige supercomputers, en om de rekenkracht die ze bieden ten volle te benutten, moet software worden geschreven met meerdere cores in gedachten - een tijdrovende en moeilijke taak die bekend staat als parallel programmeren. En veel experts zijn van mening dat, tenzij parallel programmeren gemakkelijker kan worden gemaakt, de computervooruitgang tot stilstand zal komen.
Software vereenvoudigd: StreamIt is een softwaretaal en compiler waarmee programmeurs eenvoudig multicore-machines kunnen programmeren - een taak die parallel programmeren wordt genoemd en die anders tijdrovend en moeilijk is.
Onderzoekers van het MIT zoeken naar een manier om de pijn van parallel programmeren te verlichten. Ze hebben een computertaal en een compiler ontworpen - een gespecialiseerd hulpmiddel dat de taal omzet in computerinstructies - die in wezen de uitdagingen van parallel programmeren verbergt, maar toch profiteert van de kracht van meerdere kernen. De taal en compiler, genaamd StreamIt , zijn ontwikkeld door Saman Amarasinghe , een professor in elektrotechniek en computerwetenschappen aan het MIT. StreamIt draait momenteel op een gespecialiseerde multicore-machine die is gebouwd aan het MIT, maar tegen deze zomer verwacht Amarasinghe de software klaar te hebben voor gebruik op commerciële chips van IBM, Sony en Toshiba die in Sony's PlayStation 3-machines zitten.
Software maken is nog steeds iets wat veel mensen kunnen doen, maar als ze te maken krijgen met parallellisme, wordt het veel moeilijker, zegt Amarasinghe.
In single-core machines wordt softwarecode grotendeels sequentieel uitgevoerd. Dit betekent dat taken, zoals toegang krijgen tot bepaalde stukken geheugen om een programma te openen, de een na de ander plaatsvinden, op een voorspelbare manier. In een multicore-systeem worden taken verdeeld over cores. En wanneer verschillende taken toegang moeten hebben tot hetzelfde stuk geheugen, moeten de taken samenwerken om de toegangen zorgvuldig te orkestreren of synchroniseren. Als meerdere taken onbedoeld toegang krijgen tot dezelfde gegevens zonder de juiste synchronisatie, raken de gegevens beschadigd, waardoor onjuiste resultaten worden verkregen of het programma crasht.
In single-core machines is het vrij eenvoudig om programmeerfouten of onbedoelde problemen te debuggen, omdat de oorzaak terug te voeren is op een bepaalde instructie. Maar Amarasinghe zegt dat sommige bugs in parallelle systemen moeilijker op te lossen zijn omdat ze probabilistisch zijn, wat inhoudt dat ze slechts af en toe optreden; elke keer dat het programma wordt uitgevoerd, voeren de meerdere kernen hun taken onafhankelijk uit, wat leidt tot miljarden mogelijke uitvoeringsopdrachten voor het programma.
De oplossing van Amarasinghe is gebaseerd op een bekend concept genaamd dataflow, waarbij data sequentieel door een soort pijplijn van functies wordt gestreamd. Terwijl de gegevens stromen, ziet de compiler welke functies onafhankelijk zijn. De compiler kan dus afzonderlijke taken op verschillende kernen plaatsen, zonder zich zorgen te maken dat ze met elkaar interfereren of hetzelfde stuk geheugen raken.
Een programmeur hoeft alleen software te schrijven die sequentieel werkt. De compiler ziet alle interacties die moeten plaatsvinden, gebaseerd op de code die door de programmeur is geschreven, en wijst de instructies op de juiste manier toe om te voorkomen dat bugs ontstaan.
Het is een goed idee gebaseerd op bekende concepten, zegt Bodikrace , een professor in computerwetenschappen aan de University of California, Berkeley. Als je wilt dat programmeurs die geen experts zijn in parallellisme productief zijn, als je wilt dat ze effectief programma's schrijven, dan wil je ze een taal als StreamIt geven, zegt hij. Bodik vermoedt echter dat software-engineers zullen moeten vertrouwen op een hiërarchie van tools die op verschillende niveaus werken. Zo zou transactioneel geheugen, dat het mogelijk maakt dat meerdere taken tegelijkertijd hetzelfde geheugen kunnen delen, achter de schermen werken, waardoor het potentieel van StreamIt wordt gemaximaliseerd. (Zie Het probleem met multi-core computers .)