Heute habe ich mich nach längeren Problemen mit dem Intel Graphikkarten Treiber dazu entschieden diesen zu aktualisieren. Die Ubuntu 9.04 (Jaunty) Version kam zu einem denkbar schlechten Zeitpunkt aus Sicht des Kernels und der Intel Treiber raus. Intel hat kurz vorher begonnen die Treiber komplett auf die neue Kernel Architektur umzubauen.
Mit dem Kernel 2.6.28 und den in Jaunty enthaltenen Treibern enstand eine schlecht funktionierende Version.
Seit wenigen Minuten habe ich jetzt eine Lösung für das Problem und ja meine riesigen VertexArrays funktionieren wieder.
Die Lösung war relativ einfach. Ich habe zuerst von http://kernel.ubuntu.com/~kernel-ppa/mainline/ den neuesten Kernel (derzeit 2.6.30) installiert, damit der Treiber die UXA Graphikbeschleunigung Architektur nutzen kann.
Im nächsten Schritt habe ich die Quellen von X-Updates in die sources.list von apt aufgenommen und die Treiber aktualisiert. Siehe alle Informationen hier: https://launchpad.net/~ubuntu-x-swat/+archive/x-updates.
Zusätzlich müssen noch die neuesten X.org Pakete mit den folgenden Befehlen aktualisiert werden:
CODE:
-
sudo aptitude update
-
sudo aptitude upgrade
Im letzten Schritt musste ich die xorg.conf anpassen, damit UXA genutzt wird. Dafür muss unter AccelMethod UXA aktiviert werden Der Abschnitt sieht so aus:
CODE:
-
Section "Device"
-
Identifier "Configured Video Device"
-
Driver "intel"
-
# this one is important
-
Option "AccelMethod" "UXA"
-
EndSection
In vielen Anleitungen fehlen die Anführungszeichen um "AccelMethod" was zu einer Fehlermeldung bei mir führt. Generell müssen Optionnen und die Optionen in Anführungszeichen gesetzt werden.
Quellen und weitere Hinweise:
http://www.ubuntugeek.com/new-intel-graphics-drivers-for-ubuntu-9-04-jaunty.html
Heute habe ich mich nach längeren Problemen mit dem Intel Graphikkarten Treiber dazu entschieden diesen zu aktualisieren. Die Ubuntu 9.04 (Jaunty) Version kam zu einem denkbar schlechten Zeitpunkt aus Sicht des Kernels und der Intel Treiber raus. Intel hat kurz vorher begonnen die Treiber komplett auf die neue Kernel Architektur umzubauen.
Mit dem Kernel 2.6.28 ...
geschrieben am 14. Juni 2009 um 15:00 Uhr von Konstantin Filtschew
gespeichert unter Linux |
geschrieben am 14. Juni 2009 um 13:08 Uhr von Konstantin Filtschew
gespeichert unter Aus aller Welt |
Es gibt immer wieder Aufgaben, die sehr lange dauern und sehr große Mengen an Daten verarbeiten müssen. Dabei geht es meistens um Minuten oder gar Stunden, Tage ...
Diese sollten sinnvollerweise parallelisiert werden, um die Leistungs des Systems zu nutzen. Heutige Systeme sind sehr oft Mehrkern- bzw. Mehrprozessorsysteme. Auch ist das GHz-Rennen im Moment zu Ende und die Leistung steigt über die Anzahl der Prozessoren bzw. Kerne.
Das folgende Beispiel zeigt wie man unter Java Aufgaben parallel verarbeiten kann, ohne sich groß den Kopf um die Ausführung zerbrechen zu müssen. Der ThreadPoolExecutor ist meiner Meinung nach eine sehr gute Möglichkeit Aufgaben zu parallelisieren, die Parallel ausgeführt werden können. Der große Vorteil ist, dass er Threads für das Abarbeiten am laufen hält. Das bedeutet bei neuen Aufgaben werden normalerweise keine Threads gestartet und somit entfällt faktisch dieser Overhead. Threads im Pool werden nur beendet, wenn sie länger als der festgelegte Timeout nicht benutzt werden oder sie vom Programmierer explizit beendet werden.
Nicht erschrecken. Das meiste davon sind Kommentare und Beispielcode.
Ich weiß - weniger Gelaber und her mit dem Code!
CODE:
-
import java.util.concurrent.*;
-
-
-
class MyThreadPoolExecutor
-
{
-
//Parallel running Threads(Executor) on System
-
int corePoolSize = 2;
-
-
//Maximum Threads allowed in Pool
-
int maxPoolSize = 4;
-
-
//Keep alive time for waiting threads for jobs(Runnable)
-
long keepAliveTime = 10;
-
-
//This is the one who manages and start the work
-
ThreadPoolExecutor threadPool = null;
-
-
//Working queue for jobs (Runnable). We add them finally here
-
final ArrayBlockingQueue<runnable> workQueue = new ArrayBlockingQueue</runnable><runnable>(
-
5);
-
-
public MyThreadPoolExecutor() {
-
threadPool = new ThreadPoolExecutor(corePoolSize, maxPoolSize,
-
keepAliveTime, TimeUnit.SECONDS, workQueue);
-
}
-
-
/**
-
* Here we add our jobs to working queue
-
*
-
* @param task a Runnable task
-
*/
-
public void runTask(Runnable task) {
-
threadPool.execute(task);
-
System.out.println("Tasks in workQueue.." + workQueue.size());
-
}
-
-
/**
-
* Shutdown the Threadpool if it's finished
-
*/
-
public void shutDown() {
-
threadPool.shutdown();
-
}
-
-
-
public static void main(String args[]) {
-
MyThreadPoolExecutor mtpe = new MyThreadPoolExecutor();
-
-
for (int i= 0; i <6; i++ ) {
-
mtpe.runTask(new WorkerRunnable(i));
-
}
-
-
mtpe.shutDown();
-
System.
out.
println("Finished! 
");
-
}
-
-
/**
-
* This is the one who do the work
-
*
-
* This one is static for accessing from main class
-
*/
-
private static class WorkerRunnable implements Runnable {
-
-
//so we can see which job is running
-
private int jobNr;
-
-
/**
-
* This is for understanding only
-
*
-
* @param jobNr number for displaying
-
*/
-
public WorkerRunnable(int jobNr) {
-
this.jobNr = jobNr;
-
}
-
-
@Override
-
public void run() {
-
for(int i = 0; i <10; i++) {
-
-
try {
-
System.out.println("Thread "+jobNr+" calculated "+ i);
-
Thread.currentThread().sleep(1000);
-
} catch (InterruptedException ie) {
-
ie.printStackTrace();
-
}
-
}
-
}
-
}
-
}
Da in diesem Beispiel die Anzahl der Parallel laufender Threads (corePoolSize) auf statisch 2 begrenzt ist, sollte die Zahl über Prozessoranzahl (siehe hier) bestimmt werden. Auch sollte man nicht vergessen die maximale Anzahl an Threads (maxPoolSize) entsprechend anzupassen.
Es gibt immer wieder Aufgaben, die sehr lange dauern und sehr große Mengen an Daten verarbeiten müssen. Dabei geht es meistens um Minuten oder gar Stunden, Tage ...
Diese sollten sinnvollerweise parallelisiert werden, um die Leistungs des Systems zu nutzen. Heutige Systeme sind sehr oft Mehrkern- bzw. Mehrprozessorsysteme. Auch ist das GHz-Rennen im Moment zu ...
geschrieben am 14. Juni 2009 um 11:33 Uhr von Konstantin Filtschew
gespeichert unter Java |
Da derzeitige Computersysteme in Anzahl der Prozessoren (im Moment Kerne) und nicht mehr im GHz wachsen, muss auch ein Umdenken bei der Programmierung passieren. Das bedeutet wir müssen als Programmierer Aufgaben parallelisieren oder unabhängige Prozesse bzw. Threads parallel ausführen, um die Leistung möglichst effizient ausnutzen zu können. Wenn das möglich ist, dann sollte das Programm über die Anzahl der Prozessoren (im Moment Kerne) selbstständig bestimmen, wie viele Prozesse bzw. Threads es parallel ausführt.
Das folgende Codefragment bestimmt die Prozessoranzahl unter Java:
CODE:
-
public class ProcessorCounter {
-
-
public static void main(String[] args) {
-
-
Runtime runtime = Runtime.getRuntime();
-
-
int nrOfProcessors = runtime.availableProcessors();
-
-
System.out.println("Number of processors available to the Java Virtual Machine: " + nrOfProcessors);
-
}
-
}
Da derzeitige Computersysteme in Anzahl der Prozessoren (im Moment Kerne) und nicht mehr im GHz wachsen, muss auch ein Umdenken bei der Programmierung passieren. Das bedeutet wir müssen als Programmierer Aufgaben parallelisieren oder unabhängige Prozesse bzw. Threads parallel ausführen, um die Leistung möglichst effizient ausnutzen zu können. Wenn das möglich ist, dann sollte das ...
geschrieben am 14. Juni 2009 um 10:37 Uhr von Konstantin Filtschew
gespeichert unter Java |