Multicoretechnologieën bieden belangrijke voordelen, zoals een lager energieverbruik, minder warmteontwikkeling en echte multitasking. Ze brengen echter ook een aantal uitdagingen met zich mee voor de softwareontwikkeling. Ravi Patil en Rien Schot van IBM bespreken wat een modelgebaseerde aanpak hier kan betekenen.

Multicore platforms vinden steeds meer toepassing om de toenemende honger naar performance te stillen. Ze hebben een relatief lage energiebehoefte, waardoor ze langer werken op een batterij. Daarnaast produceren ze minder hitte, zodat er geen ventilator nodig is voor de koeling. Niet alleen scheelt dat weer in het energieverbruik, ook zijn de resulterende systemen stiller en nemen ze minder ruimte in beslag. Een ander belangrijk voordeel van multicore is dat echte multitasking mogelijk is. Het applicatiemanagement kan een stuk efficiënter en rekenintensieve taken, die er steeds meer zijn, zijn zuiver parallel uit te voeren. Voorwaarde is wel dat de software daarop is ingericht. Bij multicore zijn de kloksnelheden lager en als applicaties de architectuur niet goed uitnutten, zullen de prestaties zelfs slechter zijn dan op een enkele kern.

Vier aspecten maken het ontwerpen van effectieve software voor multicore lastig. Ten eerste moeten we ontwerpbeslissingen nemen over het aantal processoren en cores, over de eigenschappen van het besturingssysteem en het interne communicatieprotocol en over de partitionering van de applicaties. Ten tweede is de complexiteit flink groter doordat de software er organisatorische taken bij krijgt, zoals communicatie tussen en toewijzing van taken aan cores, en doordat ontwerpeisen als herbruikbaarheid van componenten en schaalbaarheid voor multicore extra belangrijk zijn. Ten derde moeten we nieuwe test- en debugtechnieken inzetten. Methodes die prima voldoen voor een enkele kern blijken voor meerdere kernen namelijk niet te werken. Ten slotte vraagt multicore andere kennis en vaardigheden van de ontwerpers, die dus bijscholing moeten krijgen en deels andere werkwijzen moeten gaan hanteren.

Door de architectuur van de applicatie te modelleren en hieraan opties toe te voegen om op verschillende cores te draaien, kunnen we eenvoudig analyseren wat het effect is als we meer of minder taken toewijzen aan kernen.

Multicore en modelleren

Modelgebaseerde ontwikkeling is niet specifiek toepasbaar op multicore, maar biedt een aantal hulpmiddelen om de grotere complexiteit die meerdere kernen met zich meebrengen deels te abstraheren en deels te isoleren. Modellen kunnen onder meer van groot nut zijn bij de architectuurstudie. Om te voorkomen dat applicaties langzamer in plaats van sneller worden, is het bij multicore noodzakelijk om verschillende alternatieven door te rekenen. Hierbij moeten we de kosten van de communicatieoverhead en het delen van resources afwegen tegen de mate van parallellisme. Door de architectuur van de applicatie te modelleren en hieraan opties toe te voegen om op verschillende cores te draaien, kunnen we eenvoudig analyseren wat het effect is als we meer of minder taken toewijzen aan kernen. Het gebruik van modelsimulatie hierbij levert nog meer informatie op.

Verder is het goed om bestaande software als startpunt te nemen. Over het algemeen draait een single-coreapplicatie ook op meerdere kernen en waarom zouden we niet zo veel mogelijk hergebruiken? Vervolgstap is om de structuur van de applicatie te visualiseren en zo de samenhang van de componenten in kaart te brengen. Als laatste herstructureren we de software zodat deze de multicore architectuur optimaal benut. Het gebruik van goede tooling is hierbij essentieel om deze architectuur te waarborgen en de applicatie consistent te houden. Behalve dat we niet van scratch hoeven te beginnen met programmeren heeft deze aanpak het voordeel dat de nadruk van het testen kan liggen op de communicatie en performance, omdat de hergebruikte componenten al zijn beschreven en getest.

Wat zeker ook helpt bij het ontwikkelen van software voor multicore is het automatisch genereren van code. Dit verbetert de kwaliteit, onder meer doordat het zorgt voor een consistente implementatie van de communicatiemechanismen tussen de verschillende taken – een lastig bijkomstigheid bij multicore. De ontwerper kan zich dan volledig concentreren op een of enkele van deze mechanismen. Automatische codegeneratie maakt het ook gemakkelijker om een component te verhuizen naar een andere core, zelfs als het andere hardware betreft of een ander communicatieprotocol. Het model werkt de juiste opties uit en produceert de bijbehorende code. Dit vereenvoudigt uiteraard ook het hergebruik voor andere devices.

Ravi Patil is industriemarketingmanager bij IBM Rational Software. Rien Schot is businessleider van IBM Rational Systems in Zuid- en West-Europa. Tijdens de Model-Driven Development Day op 29 april verzorgt IBM een presentatie en een workshop over zijn MDD-benadering.