Kenjiro Taura is visting Manchester next week from the Department of Information and Communication Engineering at the University of Tokyo. He will be doing a seminar, the details of which are below:

Title: Large scale text processing made simple by GXP make: A Unixish way to parallel workflow processing

Date-time: Monday, 15 June 2009 at 11:00 AM

Location: Room MLG.001, mib.ac.uk

In the first part of this talk, I will introduce a simple tool called GXP make. GXP is a general purpose parallel shell (a process launcher) for multicore machines, unmanaged clusters accessed via SSH, clusters or supercomputers managed by batch scheduler, distributed machines, or any mixture thereof. GXP make is a ‘make‘ execution engine that executes regular UNIX makefiles in parallel. Make, though typically used for software builds, is in fact a general framework to concisely describe workflows constituting sequential commands. Installation of GXP requires no root privileges and needs to be done only on the user’s home machine. GXP make easily scales to more than 1,000 CPU cores. The net result is that GXP make allows an easy migration of workflows from serial environments to clusters and to distributed environments. In the second part, I will talk about our experiences on running a complex text processing workflow developed by Natural Language Processing (NLP) experts. It is an entire workflow that processes MEDLINE abstracts with deep NLP tools (e.g., Enju parser [1]) to generate search indices of MEDIE, a semantic retrieval engine for MEDLINE. It was originally described in Makefile without a particular provision to parallel processing, yet GXP make was able to run it on clusters with almost no changes to the original Makefile. Time for processing abstracts published in a single day was reduced from approximately eight hours (with a single machine) to twenty minutes with a trivial amount of efforts. A larger scale experiment of processing all abstracts published so far and remaining challenges will also be presented.

References

1. Miyao, Y., Sagae, K., Saetre, R., Matsuzaki, T., & Tsujii, J. (2008). Evaluating contributions of natural language parsers to protein-protein interaction extraction Bioinformatics, 25 (3), 394-400 DOI: 10.1093/bioinformatics/btn631

Heute möchte ich euch eine QT Bibliothek bekannt machen, womit ihr z.B Funktionsverläufe plotten könnt. Die Bibliothek bietet uns einige Darstellungsformen an. Hier eine kleine Liste
- Histogramm
- Spektrogramm
- Streudiagramm
- und und und…

Hierbei setze ich voraus, dass ihr VS 200X und QT installiert und konfiguriert habt.

Installation
Besorgt euch zuerst die Quelldateien von der QWT-Seite.
Als nächstes legt ihr euch ein Verzeichnis eurer Wahl an. In diesem Fall verwende ich C:\qwt als Pfad.
Entpackt nun die heruntergeladene Datei in dieses Verzeichnis.

Als nächstes wollen wir die qwtconfig.pri editieren. Der Grund hierfür ist, dass QWT standardmäßig nur als release erzeugt wird. Wir wollen aber Debug und Release also build_all!
Hierfür öffnet ihr diese Datei mit einem Texteditor.

Z.Z. ist diese stelle aktiv, die wir aber mit einem # auskommentieren werden

CONFIG += release # release/debug/debug_and_release

Stattdessen werden diese Stelle aktiviert, indem wir das # entfernen

#CONFIG += release_debug

#CONFIG += build_all

Nun speichert ihr diese Datei ab und wechselt in die Visual Studio Console, die im Startmenü erreichbar ist. Wechselt in euer soeben angelegtes QWT Verzeichnis. (cd C:\qwt)

Step1: qmake qwt.pro

Step2: nmake

Die oben genannten Befehle führt ihr nacheinander aus. Der zweite kann eine Weile dauern.

Umgebungsvariable
Auch bei QWT wollen wir in die Umgebungsvariablen. Dies erleichter nachher in VS das Leben.
Erzeugt eine neue Umgebungsvariable mit dem Namen QWTDIR und der dazugehörige Wert sollte das vorhin angelegte QWT Verzeichnis sein.

QWTDIR : C:\qwt

Als nächstes ergänzen wir unsere Umgebungsvariable “Path” indem wir zum Wert folgenden Text hinzufügen %QWTDIR%\lib .

Installation fortsetz.
Mittlerweile dürfte die Kompilierung fertig sein. Mit QWT werden auch Beispiele mitgeliefert,diese könnt ihr,wenn ihr wollt ebenfalls kompilieren. Dafür wechselt ihr in das Unterverzeichnis examples von QWT.

Step1: qmake examples.pro

Step2: nmake

Step3: admin\msvc-qmake.bat vc

Der dritte Schritt ist dafür da um Projektdateien für VS zu erstellen, damit ihr nachher die Beispiel in VS öffnen und kompilieren könnt.

QT Designer Plugin
Um die QWT widgets im QT Designer benutzen zu können, müssen wir einige Sachen kopieren. Hierzu wechselt ihr in euer QWT Verzeichnis, genauer gesagt in:
C:\qwt\designer\plugins\designer von hier kopiert ihr nun die folgenden Dateien
qwt_designer_plugin5.dll
qwt_designer_plugin5.exp
qwt_designer_plugin5.lib
qwt_designer_plugin5.dll.manifest
in euer QT-Verzeichnis, genauer gesagt in %QTDIR%\plugins\designer

QWT
Nun müssen wir nur noch die eigentlichen QWT Dateien kopieren. Dafür wechselt ihr in das Verzeichnis C:\qwt\lib.
Da wir eben sowohl für Debug also auch für Release Dateien kompiliert habe, müsst ihr hier die beiden vorfinden.
Kopiert nun die beiden DLL’s qwt5.dll und qwtd5.dll in das Verzeichnis %QTDIR%\bin

Danach kopiert ihr diese restlichen Dateien
qwt5.exp
qwtd5.exp
qwtd5.ilk
qwt5.lib
qwtd5.lib
qwtd5.pdb in das Verzeichnis %QTDIR%\lib

Nun starten sie bitte den QT Designer. Falls sie nun in der Widgetbox auf der linken Seite die QWT widgets nicht entdecken können müssen wir noch etwas erledigen.
Schließen sie den Designer und öffnen sie den Registry Editor (regedit).
Wechseln sie in dem linken Baum zu diesem Schlüssel.
HKEY_CURRENT_USER\Software\Trolltech
Hier werden sie den Schlüssel OrganizationDefaults finden. Löschen sie den gesamten Schlüssel samt Inhalt und schließen sie den Registry Editor. (Vorher ein Backup machen)
Nach einem erneuten Start des QT Designers müssten nun die QWT widgets erscheinen.

QT Toolbox (kommerzielle Nutzer)
Diejenigen, die das Glück haben und die kommerzielle Version von QT mit der VS Integration nutzen  können, müssen nun noch folgendes machen.
Wie ihr vielleicht gemerkt habt, erscheinen in der QT Toolbox die QWT widgets noch nicht aber im QT Designer schon. Der Grund hierfür ist ganz einfach
Wir müssen noch eine Runde kopieren.

Ihr müsst die Datei qwt_designer_plugin5.dll in euer QT Visual Studio Integration Verzeichnis kopieren.
Es befindet sich entweder in C:\Program Files oder in C:\Programme.
In diesem Ordner muss sich ein Unterverzeichnis für den Designer befinden, wo eventuell noch ein Ordner mit dem Namen plugins vorhanden ist. Da ich gerade die kommerzielle Version nicht zur Verfügung habe, kann ich keine genaueren Angaben machen.
In dieses Verzeichnis müsst ihr diese Datei kopieren, somit werden auch in der QT Toolbox die QWT widgets sichtbar.

VS Einstellung
Bevor wir nun loslegen können, müssen wir paar Kleinigkeiten in VS anpassen. Dafür öffnen wir VS.
Extras -> Optionen -> Projekte und Projektmappen -> VC++-Verzeichnisse
Auf der rechten Seite wählt ihr aus der rechten Kombobox “Includedateien” aus.
Unten fügt ihr folgendes hinzu: $(QWTDIR)\src
Danach wählt ihr aus der Kombobox “Bibliotheksdateien” aus.
Unten fügt ihr folgendes hinzu: $(QWTDIR)\lib
Hiermit wird VS auch bei späteren Projekten wissen, wo die LIBS und SOURCES sind.

Beispielprojekt

Nun wollen wir nach der, hoffentlich erfolgreichen, Konfiguration ein Beispielprojekt kompilieren.
Dafür wechseln wir in das Unterverzeichnis examples von QWT. (C:\qwt).
Dort wechseln wir z.B. in cpuplot und öffnen die Datei cpuplot.vcproj. Nach der Kompilierung dürftet ihr keine Fehler erhalten und die Datei ohne Probleme ausführen können.

Vergewissert euch, dass in den Präprozessor-Optionen von VS QWT_DLL eingetragen ist.
Zusätzlich sollte berücksichtigt werden, dass die Dateien qwt5d.lib (Debug) und qwt5.lib (Release) dem Linker bekannt gemacht werden müssen. Sonst treten beim linken des Projektes Fehler auf.

Troubleshoot
Falls eure qwt5.dll oder qwtd5.dll nicht gefunden wird, liegt es sehr wahrscheinlich daran, dass ihr eure Umgebungsvariablen falsch erzeugt habt. Legt sie alle (QTDIR, QWTDIR, usw..) als Systemvariablen an, bei mir wurde das Problem so gelöst.

Mit der kommerziellen Version von QT (+QT Visual Studio Integration) kann es passieren, dass QWT nicht
in der QT-Toolbox erscheint.
Lösung:

- HKEY_CURRENT_USER\Software\Trolltech\OrganisationDefaults
- HKEY_CURRENT_USER\Software\Trolltech\Designer

Diese beiden Schlüssel entfernen nun solltet ihr in Visual Studio QWT sehen können.

Falls irgendetwas unklar oder falsch sein sollte bitte die Kommentarfunktion benutzen.

Nella prima lezione, avevamo visto che per la compilazione dei sorgenti, era indispensabile il comando “qmake -project”. Questo comando crea automaticamente un .pro (del progetto). Se da un lato si ha un vantaggio perché il programmatore non deve prendersi la briga di creare un .pro dedicato, dall’altro si hanno una serie spropositata di svantaggi.

Un buon programmatore deve crearsi adeguatamente un proprio file .pro, altrimenti rischia di perdersi all’interno del progetto. La struttura di un file .pro non è difficile per niente, basta solo seguire i passi che a breve introdurrò.

Come prima cosa, un progetto Qt (o in genere un qualsiasi progetto) deve attuare un certo ordine. Non è una legge da rispettare, però seguire un certo “stile” aiuterà sicuramente il programmatore nello svolgimento delle operazioni. Ad esempio, è bene disporre i propri sorgenti all’interno di una directory “src”. Così come il file binario dentro “bin”, i file di compilazione dentro “build” e così via.

Prima di vedere come si crea un file .pro, bisogna introdurre alcuni concetti.

-> File per l’icona di windows (usato solo in windows)
In ambiente windows, i binari hanno in genere un’icona standard (quella per i .exe tradizionali). Per associare al binario un’icona, basta creare un file .rc e posizionarlo nella directory corrente del progetto.

Un esempio di tale file è questo:
IDI_ICON1 ICON DISCARDABLE "resources/icons/logo.ico"

-> File per le immagini (e in genere altri file)
In genere in un programma GUI sono presenti delle immagini, che vengono utilizzate per i menuitem, bottoni, oppure label. Ci sono 3 metodi per inserire un’immagine nel nostro programma:

1. usare path assoluti: questo metodo non merita neanche attenzione (scongiurato);
2. usare path relativi: in questi casi, le immagini hanno un percorso relativo all’eseguibile, e quindi si ha una certa “portabilità”. E’ comunque evidente che spostare il percorso del binario, implica uno sfasamento dei percorsi relativi;
3. usare path assoluti all’interno del progetto: questo modo di operare include le immagini nel binario e non si hanno modi di sbagliare.

Spiego meglio il 3° punto. Le immagini (o altri file, ad esempio file di testo) vengono convertite in file sorgenti .cpp e nello specifico, in dei vettori pieni zeppi di numeri esadecimali. Questo a noi non ci interessa… la sostanza è che le immagini verranno incluse nel binario definitivo e il loro uso nelle finestre è completamente privo di rischi.

Un file del genere specifica le “risorse” che devono essere incluse nel progetto. In genere io uso una directory “resources” e dentro di essa, posiziono il mio file di risorsa che ha un estensione .qrc. Questo file è di tipo XML e di facile utilizzo. Dentro resources, creo un’altra directory “icons” contenente tutte le immagini che userò (preferisco png a jpg). Se ad esempio, dentro “resources/icons/” ho un file immagine chiamato “logo.png”, in “resources” avrò un file .qrc del genere:

<RCC>
<qresource prefix=”/icons” >
<file>icons/logo.png</file>
</qresource>
</RCC>

Io considero indispensabili la configurazioni di questi 2 file. Detto questo, procediamo alla creazione del file .pro per il nostro progetto.

Il nostro file .pro si chiamerà Progetto.pro e sarà così composto:

# sorgenti
HEADERS += src/finestra.h
FORMS += ui/finestra.ui
SOURCES += src/finestra.cpp src/main.cpp

# build
OBJECTS_DIR += build/o
MOC_DIR += build/moc
RCC_DIR += build/rcc
UI_DIR += build/ui

# binario
DESTDIR += bin

# altro
RC_FILE += Progetto.rc
RESOURCES += resources/Progetto.qrc

• In HEADERS, FORMS e SOURCES abbiamo fissato il percorso fisico dei sorgenti e dei file delle finestre.
• In OBJECTS_DIR ci sono i file oggetto delle compilazioni, in MOC_DIR i file sorgenti dovuti alla connessione degli eventi, in RCC_DIR sono presenti i file sorgenti delle risorse e in UI_DIR i file headers delle finestre. Queste 4 variabili prendetele così come sono, e usatele per ogni progetto Qt.
• In DESTDIR andrà il binario risultante dalla compilazione totale.
• In RC_FILE c’è il file per l’icona di windows.
• In RESOURCES il file delle risorse.

Qua sotto, ecco la situazione attuale: avere impostato un progetto così significa partire ben ordinati!

A questo punto, scordatevi assolutamente il comando “qmake -project”. Dovrete da ora in poi, usare solo “qmake” e “make”.

Premetto che sono uno dei più scarsi programmatori della Terra e che quindi non voglio insegnare nulla a nessuno, però cerco di condividere quelle poche cose che so a tutti voi. Inoltre non è detto che farò altre lezioni, però per eventuali altre lezioni, il titolo sarà del tipo “Lezione Qt n: ….”. Detto questo, vediamo come creare un semplice progettino con le Qt4.

Come prima cosa, bisogna aver installato le Qt4.x e in questa sede non farò di certo vedere come installare le librerie e impostare tutte le eventuali dipendenze (compilatore c++, make, ecc). Assumo per scontato che le liberie Qt4 (occhio alla versione) siano installate correttamente.

Il nostro intento sarà quello di creare una piccola finestra che ha diversi componenti grafici: un’area testo, un bottone e una label. Lo scopo sarà quello di far visualizzare nella label il testo che scriveremo nell’area di testo dopo aver premuto l’apposito bottone.

Chi viene dalla programmazione Java e da diversi IDE come Netbeans, inizialmente si troverà (probabilmente) un pochino a disagio.

La prima cosa da fare, è la creazione di una directory per avere un po’ di pulizia. Metteremo tutto ciò che ci serve, all’interno di tale cartella.

Per disegnare la finestra, ci baseremo su designer, il magnifico programma che permette di disegnare GUI in maniera veloce e soprattutto facile… molto meglio del netbeans. Nel video qua sotto, vedremo come creare un file di finestra, che non sarà altro che un banale file XML.

Il file della finestra “finestra.ui” sarà processato in fase di compilazione in un file sorgente C++ (per l’esattezza, verrà chiamato “ui_finestra.h”).

Per usare la finestra, bisogna crearsi 2 file: “finestra.h” che conterrà la definizione della classe Finestra che creeremo, e il file “finestra.cpp” che conterrà le relative implementazioni.

La classe Finestra erediterà da 2 altre classi: da QMainWindow (che è la classe per le finestre in generale) e dalla classe Ui::MainWindow (ossia la classe MainWindow all’interno del namespace Ui che sarà generato dal file finestra.ui).

class Finestra : public QMainWindow, public Ui::MainWindow

Inoltre la classe conterrà uno “slot“, ossia un metodo normale che viene eseguito se un particolare “signal” viene attivato o generato. La macro Q_OBJECT è indispensabile per trattare questo tipo di cose.

public slots:
void stampaVideo();

Questi 2 concetti sono nuovi rispetto al Java, ma non è così difficile entrare nella logica. Un signal può essere paragonato ad un evento di “clicked” del mouse, oppure alla chiusura di una finestra, e così via. C’è da dire che un metodo slot può essere anche chiamato manualmente all’interno del codice, ma un signal non può far eseguire un metodo non slot.

Nel file di implementazione, verrà richiamato il metodo di inizializzazione componenti grafici della finestra, mediante la chiamata al metodo setupUi.

setupUi(this);

Per far si che il metodo venga chiamato al momento della pressione del bottone, è necessario “connettere” fisicamente il signal e lo slot, mediante il metodo “connect”:

connect(pushButtonScrivi, SIGNAL(clicked()), this, SLOT(stampaVideo()));

All’interno del metodo stampaVideo() metteremo il codice per prendere il testo dall’area di testo e successivamente visualizzarla nella label appena sopra.

Fatto tutto, saremo pronti alla compilazione del progetto. I passi da fare saranno 3:

• qmake -project (Serve per la creazione del file .pro del progetto. Nelle prossime lezioni, useremo file file.pro fatti da noi);
• qmake (Serve per la generazione del Makefile);
• make (Genera i file sorgenti dai file.ui, compila i file.src e crea il binario).

Alla fine, avremo nella directory corrente, il nostro eseguibile funzionante.

esempioqttargz

(da rinominare in esempioQt.tar.gz)