Jobje hier, jobje daar

nerd alertJe hebt een grote klus en een multi-core CPU (12 of meer cores) staat voor je klaar, maar vandaag de dag is het helaas nog steeds zo dat applicaties voor het grootste deel single core zijn.
Wat kan je zèlf doen, om toch het een en ander te parallelliseren?


Al sinds het begin van de ontwikkeling van de computer is het de droom van veel ICT wetenschappers dat we niet één processor steeds sneller maken, maar meerdere processoren die goed kunnen samenwerken. Maar toen kwamen dos en Windows op de markt en is parallellisme voor de meeste mensen stil komen te staan. Pas de opkomst van de 3d-videokaart ongeveer 20 jaar geleden en de opkomst van de multi-core CPU ongeveer 10 jaar geleden brachten de ontwikkeling langzaam op gang.

Het is niet de bedoeling dat het onderstaande een complete tutorial is, maar dat het voldoende inspiratie geeft om met behulp van een zoekmachine de rest van de informatie voor jouw concrete toepassing te vinden.

Lokale jobs

Misschien heb je wel eens de boodschap There are stopped jobs gezien bij het uitloggen. Maar bij de tweede keer uitloggen, lukte het gewoon wel.

Je hebt waarschijnlijk eerder zonder het te weten op ^Z (ctrl+Z) gedrukt, zodat de op dat moment lopende job op de achtergrond is gaan draaien. En er is nog veel meer dat je gewoon op de commandline kunt gebruiken:

& — aan het eind van de regel: start het commando daarvoor als een achtergrondjob
^Z — laat de voorgrondjob pauzeren op de achtergrond
jobs — geef een lijst van jobs (met jobnummers) en hun status
fg %n — maak van job nummer n de voorgrondjob
%n — hetzelfde als fg %n
bg %n — draai job nummer n verder als een achtergrondjob
kill %n — verwijder job nummer n
ps — lijst van processen (elke job bestaat uit één of meer processen)

Een job is hier een commandoregel, dus als je met bijvoorbeeld ||, && en | meerdere commando’s aan elkaar knoopt, dan vormen die samen één job.

In een grafische omgeving kan je natuurlijk meerdere shells open hebben (en in een tekstomgeving kan je met ctrl+alt+F1 t/m ctrl+alt+F6 meerdere terminals openen) en elke shell heeft een eigen voorgrondjob.

Op het moment dat je uitlogt, worden alle lopende jobs afgebroken. Er zijn verschillende manieren om dat te voorkomen, zelf vind ik de handigste manier de job draaien in een tmux sessie. Een van de alternatieven is uitzoeken hoe nohup precies werkt, maar er zijn er meer.

xargs

Als je in een bestand een lijstje bestandsnamen hebt, kan je hier met xargs een complete reeks commando’s uit laten genereren: de regels uit het bestand worden gelezen als verzameling parameters voor een commando.

xargs kan meerdere parameters op één regel zetten, zodat de betreffende bestanden achter elkaar verwerkt worden (als je commando dat ondersteunt) en kan meerdere commando’s tegelijk starten (als je commando dat toelaat). Vaak zal je met behulp van find die lijst van bestandsnamen bepalen.

Verwerk even veel commando’s parallel als je CPU cores heeft:

xargs -P `nproc`

Tutorial:

tsp

Met tsp kan je jobs in een queue zetten, zodat ze achter elkaar uitgevoerd worden.

ssh

We gaan de lokale machine verlaten en een job op een andere computer laten uitvoeren.

Voorbeeld: kijk op de machine met de naam az3735f welke versie van Ubuntu daar draait:

ssh az3735f "lsb_release -a"

Als je wilt voorkomen dat je elke keer handmatig moet inloggen op de remote computer, dan kan je een SSH key uploaden met ssh-copy-id.

Voor sommige interactieve commando’s is het nodig om de -t optie mee te geven met ssh.

parallel

parallel is een combinatie van het een en ander bovenstaande, zodat je alles kunt doen wat je nodig hebt om een clustercomputer te bouwen. parallel leidt af welke commando’s er uitgevoerd moeten worden en verdeelt de commando’s gebalanceerd over de computers die ze mogen uitvoeren. Bestanden worden heen en weer gestuurd als dat nodig is. Communicatie gebeurt via SSH, daardoor hoef je heel weinig te configureren.

Tutorial:

sheepit-renderfarm.com

Het renderen van een blender computeranimatie kost erg veel tijd. Via de website sheepit-renderfarm.com kan je de rekenkracht van je computer delen met anderen, die ook animaties willen renderen: op momenten dat je hem zelf niet nodig hebt, rendert jouw computer tekeningen voor anderen en andersom. Door je eigen computer(s) een paar maanden in leeglooptijd animaties van anderen te laten renderen, kan jouw eigen animatie later in een paar uur gerenderd zijn.

Sheepit bepaalt hoe renderopdrachten verdeeld worden over computers, soms werken er aan één opdracht honderden CPU’s en GPU’s tegelijk. Op alle CPU’s gebruikt sheepit het ingestelde aantal cores parallel.

Advertenties

2 gedachtes over “Jobje hier, jobje daar

  1. Hierboven ontbreekt cron nog. Met cron kan je een job op een bepaalde tijd laten starten, herhalend volgens een bepaald schema, of bij het herstarten van de computer.

    Andere manieren om automatisch een commando te laten starten:
    Met het bash-commando trap kan je een commando laten starten op het moment dat je de shell stopt.
    Met fswatch of inotifywait kan je een commando uitvoeren op het moment dat een bestand verandert.
    Door grep te combineren met commando’s uit deze blog, kan je een commando laten starten onder bepaalde omstandigheden, bijvoorbeeld een etherwake versturen op het moment dat er een arp-packet via het netwerk langskomt.

Vertel jouw mening

Vul je gegevens in of klik op een icoon om in te loggen.

WordPress.com logo

Je reageert onder je WordPress.com account. Log uit /  Bijwerken )

Google+ photo

Je reageert onder je Google+ account. Log uit /  Bijwerken )

Twitter-afbeelding

Je reageert onder je Twitter account. Log uit /  Bijwerken )

Facebook foto

Je reageert onder je Facebook account. Log uit /  Bijwerken )

Verbinden met %s